From 44ffa4eaf67c27e36eae6fb0bacfe1ead6e0f102 Mon Sep 17 00:00:00 2001 From: "alexey.lysiuk" Date: Sun, 17 Mar 2019 12:44:23 +0200 Subject: [PATCH] add MoltenVK 1.0.33 it's .dylib instead of static library because it will be loaded dynamically on supported versions of macOS, i.e. 10.11+ --- moltenvk/include/MoltenVK/mvk_datatypes.h | 445 + moltenvk/include/MoltenVK/mvk_vulkan.h | 45 + moltenvk/include/MoltenVK/vk_mvk_moltenvk.h | 893 + .../vk_extx_portability_subset.h | 76 + moltenvk/include/vulkan/vk_icd.h | 170 + moltenvk/include/vulkan/vk_layer.h | 195 + moltenvk/include/vulkan/vk_platform.h | 92 + moltenvk/include/vulkan/vk_sdk_platform.h | 69 + moltenvk/include/vulkan/vulkan.h | 77 + moltenvk/include/vulkan/vulkan.hpp | 55077 ++++++++++++++++ moltenvk/include/vulkan/vulkan_android.h | 126 + moltenvk/include/vulkan/vulkan_core.h | 9229 +++ moltenvk/include/vulkan/vulkan_fuchsia.h | 58 + moltenvk/include/vulkan/vulkan_ios.h | 58 + moltenvk/include/vulkan/vulkan_macos.h | 58 + moltenvk/include/vulkan/vulkan_mir.h | 65 + moltenvk/include/vulkan/vulkan_vi.h | 58 + moltenvk/include/vulkan/vulkan_wayland.h | 65 + moltenvk/include/vulkan/vulkan_win32.h | 276 + moltenvk/include/vulkan/vulkan_xcb.h | 66 + moltenvk/include/vulkan/vulkan_xlib.h | 66 + moltenvk/include/vulkan/vulkan_xlib_xrandr.h | 54 + moltenvk/lib/libMoltenVK.dylib | Bin 0 -> 2978632 bytes 23 files changed, 67318 insertions(+) create mode 100644 moltenvk/include/MoltenVK/mvk_datatypes.h create mode 100644 moltenvk/include/MoltenVK/mvk_vulkan.h create mode 100644 moltenvk/include/MoltenVK/vk_mvk_moltenvk.h create mode 100644 moltenvk/include/vulkan-portability/vk_extx_portability_subset.h create mode 100644 moltenvk/include/vulkan/vk_icd.h create mode 100644 moltenvk/include/vulkan/vk_layer.h create mode 100644 moltenvk/include/vulkan/vk_platform.h create mode 100644 moltenvk/include/vulkan/vk_sdk_platform.h create mode 100644 moltenvk/include/vulkan/vulkan.h create mode 100644 moltenvk/include/vulkan/vulkan.hpp create mode 100644 moltenvk/include/vulkan/vulkan_android.h create mode 100644 moltenvk/include/vulkan/vulkan_core.h create mode 100644 moltenvk/include/vulkan/vulkan_fuchsia.h create mode 100644 moltenvk/include/vulkan/vulkan_ios.h create mode 100644 moltenvk/include/vulkan/vulkan_macos.h create mode 100644 moltenvk/include/vulkan/vulkan_mir.h create mode 100644 moltenvk/include/vulkan/vulkan_vi.h create mode 100644 moltenvk/include/vulkan/vulkan_wayland.h create mode 100644 moltenvk/include/vulkan/vulkan_win32.h create mode 100644 moltenvk/include/vulkan/vulkan_xcb.h create mode 100644 moltenvk/include/vulkan/vulkan_xlib.h create mode 100644 moltenvk/include/vulkan/vulkan_xlib_xrandr.h create mode 100755 moltenvk/lib/libMoltenVK.dylib diff --git a/moltenvk/include/MoltenVK/mvk_datatypes.h b/moltenvk/include/MoltenVK/mvk_datatypes.h new file mode 100644 index 00000000..e509ae7a --- /dev/null +++ b/moltenvk/include/MoltenVK/mvk_datatypes.h @@ -0,0 +1,445 @@ +/* + * mvk_datatypes.h + * + * Copyright (c) 2014-2019 The Brenwill Workshop Ltd. (http://www.brenwill.com) + * + * 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 contains functions for converting between Vulkan and Metal data types. + * + * The functions here are used internally by MoltenVK, and are exposed here + * as a convenience for use elsewhere within applications using MoltenVK. + */ + +#ifndef __mvkDataTypes_h_ +#define __mvkDataTypes_h_ 1 + +#ifdef __cplusplus +extern "C" { +#endif // __cplusplus + +#include "mvk_vulkan.h" + +#import +#import + + +#pragma mark - +#pragma mark Image properties + +#pragma mark Texture formats + +/** Enumerates the data type of a format. */ +typedef enum { + kMVKFormatNone, /**< Format type is unknown. */ + kMVKFormatColorHalf, /**< A 16-bit floating point color. */ + kMVKFormatColorFloat, /**< A 32-bit floating point color. */ + kMVKFormatColorInt8, /**< A signed 8-bit integer color. */ + kMVKFormatColorUInt8, /**< An unsigned 8-bit integer color. */ + kMVKFormatColorInt16, /**< A signed 16-bit integer color. */ + kMVKFormatColorUInt16, /**< An unsigned 16-bit integer color. */ + kMVKFormatColorInt32, /**< A signed 32-bit integer color. */ + kMVKFormatColorUInt32, /**< An unsigned 32-bit integer color. */ + kMVKFormatDepthStencil, /**< A depth and stencil value. */ + kMVKFormatCompressed, /**< A block-compressed color. */ +} MVKFormatType; + +/** Returns whether the VkFormat is supported by this implementation. */ +bool mvkVkFormatIsSupported(VkFormat vkFormat); + +/** Returns whether the MTLPixelFormat is supported by this implementation. */ +bool mvkMTLPixelFormatIsSupported(MTLPixelFormat mtlFormat); + +/** Returns the format type corresponding to the specified Vulkan VkFormat, */ +MVKFormatType mvkFormatTypeFromVkFormat(VkFormat vkFormat); + +/** Returns the format type corresponding to the specified Metal MTLPixelFormat, */ +MVKFormatType mvkFormatTypeFromMTLPixelFormat(MTLPixelFormat mtlFormat); + +/** + * Returns the Metal MTLPixelFormat corresponding to the specified Vulkan VkFormat, + * or returns MTLPixelFormatInvalid if no corresponding MTLPixelFormat exists. + * + * Not all MTLPixelFormats returned by this function are supported by all GPU's, + * and, internally, MoltenVK may substitute and use a different MTLPixelFormat than + * is returned by this function for a particular Vulkan VkFormat value. + * + * Not all macOS GPU's support the MTLPixelFormatDepth24Unorm_Stencil8 pixel format. + * Even though this function will return that value when passed the corresponding + * VkFormat value, internally, MoltenVK will use the MTLPixelFormatDepth32Float_Stencil8 + * instead when a GPU does not support the MTLPixelFormatDepth24Unorm_Stencil8 pixel format. + * On an macOS device that has more than one GPU, one of the GPU's may support the + * MTLPixelFormatDepth24Unorm_Stencil8 pixel format while another may not. + */ +MTLPixelFormat mvkMTLPixelFormatFromVkFormat(VkFormat vkFormat); + +/** + * Returns the Vulkan VkFormat corresponding to the specified Metal MTLPixelFormat, + * or returns VK_FORMAT_UNDEFINED if no corresponding VkFormat exists. + */ +VkFormat mvkVkFormatFromMTLPixelFormat(MTLPixelFormat mtlFormat); + +/** + * Returns the size, in bytes, of a texel block of the specified Vulkan format. + * For uncompressed formats, the returned value corresponds to the size in bytes of a single texel. + */ +uint32_t mvkVkFormatBytesPerBlock(VkFormat vkFormat); + +/** + * Returns the size, in bytes, of a texel block of the specified Metal format. + * For uncompressed formats, the returned value corresponds to the size in bytes of a single texel. + */ +uint32_t mvkMTLPixelFormatBytesPerBlock(MTLPixelFormat mtlFormat); + +/** + * Returns the size of the compression block, measured in texels for a Vulkan format. + * The returned value will be {1, 1} for non-compressed formats. + */ +VkExtent2D mvkVkFormatBlockTexelSize(VkFormat vkFormat); + +/** + * Returns the size of the compression block, measured in texels for a Metal format. + * The returned value will be {1, 1} for non-compressed formats. + */ +VkExtent2D mvkMTLPixelFormatBlockTexelSize(MTLPixelFormat mtlFormat); + +/** + * Returns the size, in bytes, of a texel of the specified Vulkan format. + * The returned value may be fractional for certain compressed formats. + */ +float mvkVkFormatBytesPerTexel(VkFormat vkFormat); + +/** + * Returns the size, in bytes, of a texel of the specified Metal format. + * The returned value may be fractional for certain compressed formats. + */ +float mvkMTLPixelFormatBytesPerTexel(MTLPixelFormat mtlFormat); + +/** + * Returns the size, in bytes, of a row of texels of the specified Vulkan format. + * + * For compressed formats, this takes into consideration the compression block size, + * and texelsPerRow should specify the width in texels, not blocks. The result is rounded + * up if texelsPerRow is not an integer multiple of the compression block width. + */ +size_t mvkVkFormatBytesPerRow(VkFormat vkFormat, uint32_t texelsPerRow); + +/** + * Returns the size, in bytes, of a row of texels of the specified Metal format. + * + * For compressed formats, this takes into consideration the compression block size, + * and texelsPerRow should specify the width in texels, not blocks. The result is rounded + * up if texelsPerRow is not an integer multiple of the compression block width. + */ +size_t mvkMTLPixelFormatBytesPerRow(MTLPixelFormat mtlFormat, uint32_t texelsPerRow); + +/** + * Returns the size, in bytes, of a texture layer of the specified Vulkan format. + * + * For compressed formats, this takes into consideration the compression block size, + * and texelRowsPerLayer should specify the height in texels, not blocks. The result is + * rounded up if texelRowsPerLayer is not an integer multiple of the compression block height. + */ +size_t mvkVkFormatBytesPerLayer(VkFormat vkFormat, size_t bytesPerRow, uint32_t texelRowsPerLayer); + +/** + * Returns the size, in bytes, of a texture layer of the specified Metal format. + * For compressed formats, this takes into consideration the compression block size, + * and texelRowsPerLayer should specify the height in texels, not blocks. The result is + * rounded up if texelRowsPerLayer is not an integer multiple of the compression block height. + */ +size_t mvkMTLPixelFormatBytesPerLayer(MTLPixelFormat mtlFormat, size_t bytesPerRow, uint32_t texelRowsPerLayer); + +/** + * Returns the default properties for the specified Vulkan format. + * + * Not all MTLPixelFormats returned by this function are supported by all GPU's, and, as a + * result, MoltenVK may return a different value from the vkGetPhysicalDeviceFormatProperties() + * function than is returned here. Use the vkGetPhysicalDeviceFormatProperties() function to + * return the properties for a particular GPU. + * + * Setting assumeGPUSupportsDefault to true allows the default format properties to be returned. + * The assumeGPUSupportsDefault flag can be set to false if it is already known that the format + * is not supported by a particular GPU for images, in which case all of the returned properties + * will be disabled, except possibly VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT, which may be supported + * for the format even without image support. + */ +VkFormatProperties mvkVkFormatProperties(VkFormat vkFormat, bool assumeGPUSupportsDefault = true); + +/** Returns the name of the specified Vulkan format. */ +const char* mvkVkFormatName(VkFormat vkFormat); + +/** Returns the name of the specified Metal pixel format. */ +const char* mvkMTLPixelFormatName(MTLPixelFormat mtlFormat); + +/** + * Returns the MTLClearColor value corresponding to the color value in the VkClearValue, + * extracting the color value that is VkFormat for the VkFormat. + */ +MTLClearColor mvkMTLClearColorFromVkClearValue(VkClearValue vkClearValue, + VkFormat vkFormat); + +/** Returns the Metal depth value corresponding to the depth value in the specified VkClearValue. */ +double mvkMTLClearDepthFromVkClearValue(VkClearValue vkClearValue); + +/** Returns the Metal stencil value corresponding to the stencil value in the specified VkClearValue. */ +uint32_t mvkMTLClearStencilFromVkClearValue(VkClearValue vkClearValue); + +/** Returns whether the specified Metal MTLPixelFormat can be used as a depth format. */ +bool mvkMTLPixelFormatIsDepthFormat(MTLPixelFormat mtlFormat); + +/** Returns whether the specified Metal MTLPixelFormat can be used as a stencil format. */ +bool mvkMTLPixelFormatIsStencilFormat(MTLPixelFormat mtlFormat); + +/** Returns whether the specified Metal MTLPixelFormat is a PVRTC format. */ +bool mvkMTLPixelFormatIsPVRTCFormat(MTLPixelFormat mtlFormat); + +/** Returns the Metal texture type from the specified Vulkan image properties. */ +MTLTextureType mvkMTLTextureTypeFromVkImageType(VkImageType vkImageType, + uint32_t arraySize, + bool isMultisample); + +/** Returns the Vulkan image type from the Metal texture type. */ +VkImageType mvkVkImageTypeFromMTLTextureType(MTLTextureType mtlTextureType); + +/** Returns the Metal MTLTextureType corresponding to the Vulkan VkImageViewType. */ +MTLTextureType mvkMTLTextureTypeFromVkImageViewType(VkImageViewType vkImageViewType, bool isMultisample); + +/** Returns the Metal texture usage from the Vulkan image usage. */ +MTLTextureUsage mvkMTLTextureUsageFromVkImageUsageFlags(VkImageUsageFlags vkImageUsageFlags); + +/** Returns the Vulkan image usage from the Metal texture usage and format. */ +VkImageUsageFlags mvkVkImageUsageFlagsFromMTLTextureUsage(MTLTextureUsage mtlUsage, MTLPixelFormat mtlFormat); + +/** + * Returns the numeric sample count corresponding to the specified Vulkan sample count flag. + * + * The specified flags value should have only one bit set, otherwise an invalid numeric value will be returned. + */ +uint32_t mvkSampleCountFromVkSampleCountFlagBits(VkSampleCountFlagBits vkSampleCountFlag); + +/** Returns the Vulkan bit flags corresponding to the numeric sample count, which must be a PoT value. */ +VkSampleCountFlagBits mvkVkSampleCountFlagBitsFromSampleCount(NSUInteger sampleCount); + + +#pragma mark Mipmaps + +/** + * Returns the number of mipmap levels available to an image with the specified side dimension. + * + * If the specified dimension is a power-of-two, the value returned is (log2(dim) + 1). + * If the specified dimension is NOT a power-of-two, the value returned is 0, indicating + * that the image cannot support mipmaps. + */ +uint32_t mvkMipmapLevels(uint32_t dim); + +/** + * Returns the number of mipmap levels available to an image with the specified extent. + * + * If each dimension in the specified extent is a power-of-two, the value returned + * is MAX(log2(dim) + 1) across both dimensions. If either dimension in the specified + * extent is NOT a power-of-two, the value returned is 1, indicating that the image + * cannot support mipmaps, and that only the base mip level can be used. + */ +uint32_t mvkMipmapLevels2D(VkExtent2D extent); + +/** + * Returns the number of mipmap levels available to an image with the specified extent. + * + * If each dimension in the specified extent is a power-of-two, the value returned + * is MAX(log2(dim) + 1) across all dimensions. If either dimension in the specified + * extent is NOT a power-of-two, the value returned is 1, indicating that the image + * cannot support mipmaps, and that only the base mip level can be used. + */ +uint32_t mvkMipmapLevels3D(VkExtent3D extent); + +/** + * Returns the size of the specified zero-based mipmap level, + * when the size of the base level is the specified size. + */ +VkExtent2D mvkMipmapLevelSizeFromBaseSize2D(VkExtent2D baseSize, uint32_t level); + +/** + * Returns the size of the specified zero-based mipmap level, + * when the size of the base level is the specified size. + */ +VkExtent3D mvkMipmapLevelSizeFromBaseSize3D(VkExtent3D baseSize, uint32_t level); + +/** + * Returns the size of the mipmap base level, when the size of + * the specified zero-based mipmap level is the specified size. + */ +VkExtent2D mvkMipmapBaseSizeFromLevelSize2D(VkExtent2D levelSize, uint32_t level); + +/** + * Returns the size of the mipmap base level, when the size of + * the specified zero-based mipmap level is the specified size. + */ +VkExtent3D mvkMipmapBaseSizeFromLevelSize3D(VkExtent3D levelSize, uint32_t level); + + +#pragma mark Samplers + +/** + * Returns the Metal MTLSamplerAddressMode corresponding to the specified Vulkan VkSamplerAddressMode, + * or returns MTLSamplerAddressModeMirrorClampToEdge if no corresponding MTLSamplerAddressMode exists. + */ +MTLSamplerAddressMode mvkMTLSamplerAddressModeFromVkSamplerAddressMode(VkSamplerAddressMode vkMode); + +#if MVK_MACOS +/** + * Returns the Metal MTLSamplerBorderColor corresponding to the specified Vulkan VkBorderColor, + * or returns MTLSamplerBorderColorTransparentBlack if no corresponding MTLSamplerBorderColor exists. + */ +MTLSamplerBorderColor mvkMTLSamplerBorderColorFromVkBorderColor(VkBorderColor vkColor); +#endif + +/** + * Returns the Metal MTLSamplerMinMagFilter corresponding to the specified Vulkan VkFilter, + * or returns MTLSamplerMinMagFilterNearest if no corresponding MTLSamplerMinMagFilter exists. + */ +MTLSamplerMinMagFilter mvkMTLSamplerMinMagFilterFromVkFilter(VkFilter vkFilter); + +/** + * Returns the Metal MTLSamplerMipFilter corresponding to the specified Vulkan VkSamplerMipmapMode, + * or returns MTLSamplerMipFilterNotMipmapped if no corresponding MTLSamplerMipFilter exists. + */ +MTLSamplerMipFilter mvkMTLSamplerMipFilterFromVkSamplerMipmapMode(VkSamplerMipmapMode vkMode); + + +#pragma mark - +#pragma mark Render pipeline + +/** Returns the Metal MTLColorWriteMask corresponding to the specified Vulkan VkColorComponentFlags. */ +MTLColorWriteMask mvkMTLColorWriteMaskFromVkChannelFlags(VkColorComponentFlags vkWriteFlags); + +/** Returns the Metal MTLBlendOperation corresponding to the specified Vulkan VkBlendOp. */ +MTLBlendOperation mvkMTLBlendOperationFromVkBlendOp(VkBlendOp vkBlendOp); + +/** Returns the Metal MTLBlendFactor corresponding to the specified Vulkan VkBlendFactor. */ +MTLBlendFactor mvkMTLBlendFactorFromVkBlendFactor(VkBlendFactor vkBlendFactor); + +/** + * Returns the Metal MTLVertexFormat corresponding to the specified + * Vulkan VkFormat as used as a vertex attribute format. + */ +MTLVertexFormat mvkMTLVertexFormatFromVkFormat(VkFormat vkFormat); + +/** Returns the Metal MTLVertexStepFunction corresponding to the specified Vulkan VkVertexInputRate. */ +MTLVertexStepFunction mvkMTLVertexStepFunctionFromVkVertexInputRate(VkVertexInputRate vkVtxStep); + +/** Returns the Metal MTLPrimitiveType corresponding to the specified Vulkan VkPrimitiveTopology. */ +MTLPrimitiveType mvkMTLPrimitiveTypeFromVkPrimitiveTopology(VkPrimitiveTopology vkTopology); + +/** Returns the Metal MTLPrimitiveTopologyClass corresponding to the specified Vulkan VkPrimitiveTopology. */ +MTLPrimitiveTopologyClass mvkMTLPrimitiveTopologyClassFromVkPrimitiveTopology(VkPrimitiveTopology vkTopology); + +/** Returns the Metal MTLTriangleFillMode corresponding to the specified Vulkan VkPolygonMode, */ +MTLTriangleFillMode mvkMTLTriangleFillModeFromVkPolygonMode(VkPolygonMode vkFillMode); + +/** Returns the Metal MTLLoadAction corresponding to the specified Vulkan VkAttachmentLoadOp. */ +MTLLoadAction mvkMTLLoadActionFromVkAttachmentLoadOp(VkAttachmentLoadOp vkLoadOp); + +/** Returns the Metal MTLStoreAction corresponding to the specified Vulkan VkAttachmentStoreOp. */ +MTLStoreAction mvkMTLStoreActionFromVkAttachmentStoreOp(VkAttachmentStoreOp vkStoreOp, bool hasResolveAttachment = false); + +/** Returns the Metal MTLViewport corresponding to the specified Vulkan VkViewport. */ +MTLViewport mvkMTLViewportFromVkViewport(VkViewport vkViewport); + +/** Returns the Metal MTLScissorRect corresponding to the specified Vulkan VkRect2D. */ +MTLScissorRect mvkMTLScissorRectFromVkRect2D(VkRect2D vkRect); + +/** Returns the Metal MTLCompareFunction corresponding to the specified Vulkan VkCompareOp, */ +MTLCompareFunction mvkMTLCompareFunctionFromVkCompareOp(VkCompareOp vkOp); + +/** Returns the Metal MTLStencilOperation corresponding to the specified Vulkan VkStencilOp, */ +MTLStencilOperation mvkMTLStencilOperationFromVkStencilOp(VkStencilOp vkOp); + +/** Returns the Metal MTLCullMode corresponding to the specified Vulkan VkCullModeFlags, */ +MTLCullMode mvkMTLCullModeFromVkCullModeFlags(VkCullModeFlags vkCull); + +/** Returns the Metal MTLWinding corresponding to the specified Vulkan VkFrontFace, */ +MTLWinding mvkMTLWindingFromVkFrontFace(VkFrontFace vkWinding); + +/** Returns the Metal MTLIndexType corresponding to the specified Vulkan VkIndexType, */ +MTLIndexType mvkMTLIndexTypeFromVkIndexType(VkIndexType vkIdxType); + +/** Returns the size, in bytes, of a vertex index of the specified type. */ +size_t mvkMTLIndexTypeSizeInBytes(MTLIndexType mtlIdxType); + + +#pragma mark - +#pragma mark Geometry conversions + +/** Returns a VkExtent2D that corresponds to the specified CGSize. */ +static inline VkExtent2D mvkVkExtent2DFromCGSize(CGSize cgSize) { + VkExtent2D vkExt; + vkExt.width = cgSize.width; + vkExt.height = cgSize.height; + return vkExt; +} + +/** Returns a Metal MTLOrigin constructed from a VkOffset3D. */ +static inline MTLOrigin mvkMTLOriginFromVkOffset3D(VkOffset3D vkOffset) { + return MTLOriginMake(vkOffset.x, vkOffset.y, vkOffset.z); +} + +/** Returns a Vulkan VkOffset3D constructed from a Metal MTLOrigin. */ +static inline VkOffset3D mvkVkOffset3DFromMTLSize(MTLOrigin mtlOrigin) { + return { (int32_t)mtlOrigin.x, (int32_t)mtlOrigin.y, (int32_t)mtlOrigin.z }; +} + +/** Returns a Metal MTLSize constructed from a VkExtent3D. */ +static inline MTLSize mvkMTLSizeFromVkExtent3D(VkExtent3D vkExtent) { + return MTLSizeMake(vkExtent.width, vkExtent.height, vkExtent.depth); +} + +/** Returns a Vulkan VkExtent3D constructed from a Metal MTLSize. */ +static inline VkExtent3D mvkVkExtent3DFromMTLSize(MTLSize mtlSize) { + return { (uint32_t)mtlSize.width, (uint32_t)mtlSize.height, (uint32_t)mtlSize.depth }; +} + + +#pragma mark - +#pragma mark Memory options + +/** Macro indicating the Vulkan memory type bits corresponding to Metal private memory (not host visible). */ +#define MVK_VK_MEMORY_TYPE_METAL_PRIVATE (VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) + +/** Macro indicating the Vulkan memory type bits corresponding to Metal managed memory (host visible and non-coherent). */ +#define MVK_VK_MEMORY_TYPE_METAL_MANAGED (VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT) + +/** Macro indicating the Vulkan memory type bits corresponding to Metal shared memory (host visible and coherent). */ +#define MVK_VK_MEMORY_TYPE_METAL_SHARED (VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT) + +/** Macro indicating the Vulkan memory type bits corresponding to Metal memoryless memory (not host visible and lazily allocated). */ +#define MVK_VK_MEMORY_TYPE_METAL_MEMORYLESS (VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) + +/** Returns the Metal storage mode corresponding to the specified Vulkan memory flags. */ +MTLStorageMode mvkMTLStorageModeFromVkMemoryPropertyFlags(VkMemoryPropertyFlags vkFlags); + +/** Returns the Metal CPU cache mode corresponding to the specified Vulkan memory flags. */ +MTLCPUCacheMode mvkMTLCPUCacheModeFromVkMemoryPropertyFlags(VkMemoryPropertyFlags vkFlags); + +/** Returns the Metal resource option flags corresponding to the specified Vulkan memory flags. */ +MTLResourceOptions mvkMTLResourceOptionsFromVkMemoryPropertyFlags(VkMemoryPropertyFlags vkFlags); + + +#ifdef __cplusplus +} +#endif // __cplusplus + +#endif diff --git a/moltenvk/include/MoltenVK/mvk_vulkan.h b/moltenvk/include/MoltenVK/mvk_vulkan.h new file mode 100644 index 00000000..1277064e --- /dev/null +++ b/moltenvk/include/MoltenVK/mvk_vulkan.h @@ -0,0 +1,45 @@ +/* + * mvk_vulkan.h + * + * Copyright (c) 2014-2019 The Brenwill Workshop Ltd. (http://www.brenwill.com) + * + * 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 is a convenience header file that loads vulkan.h with the appropriate MoltenVK + * Vulkan platform extensions automatically enabled for iOS or macOS. + * + * When building for iOS, this header automatically enables the VK_MVK_ios_surface Vulkan extension. + * When building for macOS, this header automatically enables the VK_MVK_macos_surface Vulkan extension. + */ + +#ifndef __mvk_vulkan_h_ +#define __mvk_vulkan_h_ 1 + + +#include + +#ifdef __IPHONE_OS_VERSION_MAX_ALLOWED +# define VK_USE_PLATFORM_IOS_MVK 1 +#endif + +#ifdef __MAC_OS_X_VERSION_MAX_ALLOWED +# define VK_USE_PLATFORM_MACOS_MVK 1 +#endif + +#include +#include + +#endif diff --git a/moltenvk/include/MoltenVK/vk_mvk_moltenvk.h b/moltenvk/include/MoltenVK/vk_mvk_moltenvk.h new file mode 100644 index 00000000..b8a20aa9 --- /dev/null +++ b/moltenvk/include/MoltenVK/vk_mvk_moltenvk.h @@ -0,0 +1,893 @@ +/* + * vk_mvk_moltenvk.h + * + * Copyright (c) 2014-2019 The Brenwill Workshop Ltd. (http://www.brenwill.com) + * + * 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. + */ + + +/** Vulkan extension VK_MVK_moltenvk. */ + +#ifndef __vk_mvk_moltenvk_h_ +#define __vk_mvk_moltenvk_h_ 1 + +#ifdef __cplusplus +extern "C" { +#endif // __cplusplus + +#include "mvk_vulkan.h" + +#ifdef __OBJC__ +#import +#import +#else +typedef unsigned long MTLLanguageVersion; +#endif + + +/** + * The version number of MoltenVK is a single integer value, derived from the Major, Minor, + * and Patch version values, where each of the Major, Minor, and Patch components is allocated + * two decimal digits, in the format MjMnPt. This creates a version number that is both human + * readable and allows efficient computational comparisons to a single integer number. + * + * The following examples illustrate how the MoltenVK version number is built from its components: + * - 002000 (version 0.20.0) + * - 010000 (version 1.0.0) + * - 030104 (version 3.1.4) + * - 401215 (version 4.12.15) + */ +#define MVK_VERSION_MAJOR 1 +#define MVK_VERSION_MINOR 0 +#define MVK_VERSION_PATCH 33 + +#define MVK_MAKE_VERSION(major, minor, patch) (((major) * 10000) + ((minor) * 100) + (patch)) +#define MVK_VERSION MVK_MAKE_VERSION(MVK_VERSION_MAJOR, MVK_VERSION_MINOR, MVK_VERSION_PATCH) + +#define VK_MVK_MOLTENVK_SPEC_VERSION 18 +#define VK_MVK_MOLTENVK_EXTENSION_NAME "VK_MVK_moltenvk" + +/** + * MoltenVK configuration settings. + * + * To be active, some configuration settings must be set before a VkDevice is created. + * See the description of the individual configuration structure members for more information. + * + * There are three mechanisms for setting the values of the MoltenVK configuration parameters: + * - Runtime API via the vkGetMoltenVKConfigurationMVK()/vkSetMoltenVKConfigurationMVK() functions. + * - Application runtime environment variables. + * - Build settings at MoltenVK build time. + * + * To change the MoltenVK configuration settings at runtime using a programmatic API, + * use the vkGetMoltenVKConfigurationMVK() and vkSetMoltenVKConfigurationMVK() functions + * to retrieve, modify, and set a copy of the MVKConfiguration structure. + * + * The initial value of each of the configuration settings can established at runtime + * by a corresponding environment variable, or if the environment variable is not set, + * by a corresponding build setting at the time MoltenVK is compiled. The environment + * variable and build setting for each configuration parameter share the same name. + * + * For example, the initial value of the shaderConversionFlipVertexY configuration setting + * is set by the MVK_CONFIG_SHADER_CONVERSION_FLIP_VERTEX_Y at runtime, or by the + * MVK_CONFIG_SHADER_CONVERSION_FLIP_VERTEX_Y build setting when MoltenVK is compiled. + * + * This structure may be extended as new features are added to MoltenVK. If you are linking to + * an implementation of MoltenVK that was compiled from a different VK_MVK_MOLTENVK_SPEC_VERSION + * than your app was, the size of this structure in your app may be larger or smaller than the + * struct in MoltenVK. See the description of the vkGetMoltenVKConfigurationMVK() and + * vkSetMoltenVKConfigurationMVK() functions for information about how to handle this. + * + * TO SUPPORT DYNAMIC LINKING TO THIS STRUCTURE AS DESCRIBED ABOVE, THIS STRUCTURE SHOULD NOT + * BE CHANGED EXCEPT TO ADD ADDITIONAL MEMBERS ON THE END. EXISTING MEMBERS, AND THEIR ORDER, + * SHOULD NOT BE CHANGED. + * + * In addition to the configuration parmeters in this structure, there are several settings that + * can be configured through runtime environment variables or MoltenVK compile-time build settings: + * + * 1. The MVK_CONFIG_LOG_LEVEL runtime environment variable or MoltenVK compile-time build setting + * controls the level of logging performned by MoltenVK using the following numeric values: + * 0: No logging. + * 1: Log errors only. + * 2: Log errors and informational messages. + * If neither is set, errors and informational messages are logged. + * + * 2. Setting the MVK_CONFIG_FORCE_LOW_POWER_GPU runtime environment variable or MoltenVK compile-time + * build setting to 1 will force MoltenVK to use a low-power GPU, if one is availble on the device. + * + */ +typedef struct { + + /** + * If enabled, debugging capabilities will be enabled, including logging + * shader code during runtime shader conversion. + * + * The value of this parameter may be changed at any time during application runtime, + * and the changed value will immediately effect subsequent MoltenVK behaviour. + * + * The initial value or this parameter is set by the + * MVK_DEBUG + * runtime environment variable or MoltenVK compile-time build setting. + * If neither is set, the value of this parameter is false if MoltenVK was + * built in Release mode, and true if MoltenVK was built in Debug mode. + */ + VkBool32 debugMode; + + /** + * If enabled, MSL vertex shader code created during runtime shader conversion will + * flip the Y-axis of each vertex, as the Vulkan Y-axis is the inverse of OpenGL. + * + * An alternate way to reverse the Y-axis is to employ a negative Y-axis value on + * the viewport, in which case this parameter can be disabled. + * + * The value of this parameter may be changed at any time during application runtime, + * and the changed value will immediately effect subsequent MoltenVK behaviour. + * Specifically, this parameter can be enabled when compiling some pipelines, + * and disabled when compiling others. Existing pipelines are not automatically + * re-compiled when this parameter is changed. + * + * The initial value or this parameter is set by the + * MVK_CONFIG_SHADER_CONVERSION_FLIP_VERTEX_Y + * runtime environment variable or MoltenVK compile-time build setting. + * If neither is set, the value of this parameter defaults to true. + */ + VkBool32 shaderConversionFlipVertexY; + + /** + * If enabled, queue command submissions (vkQueueSubmit() & vkQueuePresentKHR()) will be + * processed on the thread that called the submission function. If disabled, processing + * will be dispatched to a GCD dispatch_queue whose priority is determined by + * VkDeviceQueueCreateInfo::pQueuePriorities during vkCreateDevice(). + * + * The value of this parameter must be changed before creating a VkDevice, + * for the change to take effect. + * + * The initial value or this parameter is set by the + * MVK_CONFIG_SYNCHRONOUS_QUEUE_SUBMITS + * runtime environment variable or MoltenVK compile-time build setting. + * If neither is set, the value of this parameter defaults to true. + */ + VkBool32 synchronousQueueSubmits; + + /** + * If enabled, where possible, a Metal command buffer will be created and filled when each + * Vulkan command buffer is filled. For applications that parallelize the filling of Vulkan + * commmand buffers across multiple threads, this allows the Metal command buffers to also + * be filled on the same parallel thread. Because each command buffer is filled separately, + * this requires that each Vulkan command buffer requires a dedicated Metal command buffer. + * + * If disabled, a single Metal command buffer will be created and filled when the Vulkan + * command buffers are submitted to the Vulkan queue. This allows a single Metal command + * buffer to be used for all of the Vulkan command buffers in a queue submission. The + * Metal command buffer is filled on the thread that processes the command queue submission. + * + * Depending on the nature of your application, you may find performance is improved by filling + * the Metal command buffers on parallel threads, or you may find that performance is improved by + * consolidating all Vulkan command buffers onto a single Metal command buffer during queue submission. + * + * Prefilling of a Metal command buffer will not occur during the filling of secondary command + * buffers (VK_COMMAND_BUFFER_LEVEL_SECONDARY), or for primary command buffers that are intended + * to be submitted to multiple queues concurrently (VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT). + * + * When enabling this features, be aware that one Metal command buffer is required for each Vulkan + * command buffer. Depending on the number of command buffers that you use, you may also need to + * change the value of the maxActiveMetalCommandBuffersPerQueue setting. + * + * In addition, if this feature is enabled, be aware that if you have recorded commands to a + * Vulkan command buffer, and then choose to reset that command buffer instead of submitting it, + * the corresponding prefilled Metal command buffer will still be submitted. This is because Metal + * command buffers do not support the concept of being reset after being filled. Depending on when + * and how often you do this, it may cause unexpected visual artifacts and unnecessary GPU load. + * + * The value of this parameter may be changed at any time during application runtime, + * and the changed value will immediately effect subsequent MoltenVK behaviour. + * Specifically, this parameter can be enabled when filling some command buffers, + * and disabled when filling others. + * + * The initial value or this parameter is set by the + * MVK_CONFIG_PREFILL_METAL_COMMAND_BUFFERS + * runtime environment variable or MoltenVK compile-time build setting. + * If neither is set, the value of this parameter defaults to false. + */ + VkBool32 prefillMetalCommandBuffers; + + /** + * The maximum number of Metal command buffers that can be concurrently active per Vulkan queue. + * The number of active Metal command buffers required depends on the prefillMetalCommandBuffers + * setting. If prefillMetalCommandBuffers is enabled, one Metal command buffer is required per + * Vulkan command buffer. If prefillMetalCommandBuffers is disabled, one Metal command buffer + * is required per command buffer queue submission, which may be significantly less than the + * number of Vulkan command buffers. + * + * The value of this parameter must be changed before creating a VkDevice, + * for the change to take effect. + * + * The initial value or this parameter is set by the + * MVK_CONFIG_MAX_ACTIVE_METAL_COMMAND_BUFFERS_PER_QUEUE + * runtime environment variable or MoltenVK compile-time build setting. + * If neither is set, the value of this parameter defaults to 64. + */ + uint32_t maxActiveMetalCommandBuffersPerQueue; + + /** + * Metal allows only 8192 occlusion queries per MTLBuffer. If enabled, MoltenVK + * allocates a MTLBuffer for each query pool, allowing each query pool to support + * 8192 queries, which may slow performance or cause unexpected behaviour if the query + * pool is not established prior to a Metal renderpass, or if the query pool is changed + * within a renderpass. If disabled, one MTLBuffer will be shared by all query pools, + * which improves performance, but limits the total device queries to 8192. + * + * The value of this parameter may be changed at any time during application runtime, + * and the changed value will immediately effect subsequent MoltenVK behaviour. + * Specifically, this parameter can be enabled when creating some query pools, + * and disabled when creating others. + * + * The initial value or this parameter is set by the + * MVK_CONFIG_SUPPORT_LARGE_QUERY_POOLS + * runtime environment variable or MoltenVK compile-time build setting. + * If neither is set, the value of this parameter defaults to true. + */ + VkBool32 supportLargeQueryPools; + + /** + * If enabled, each surface presentation is scheduled using a command buffer. Enabling this + * setting may improve rendering frame synchronization, but may result in reduced frame rates. + * + * The value of this parameter may be changed at any time during application runtime, + * and the changed value will immediately effect subsequent MoltenVK behaviour. + * + * The initial value or this parameter is set by the + * MVK_CONFIG_PRESENT_WITH_COMMAND_BUFFER + * runtime environment variable or MoltenVK compile-time build setting. + * If neither is set, the value of this parameter defaults to true. + */ + VkBool32 presentWithCommandBuffer; + + /** + * If enabled, swapchain images will use simple Nearest sampling when magnifying the + * swapchain image to fit a physical display surface. If disabled, swapchain images will + * use Linear sampling when magnifying the swapchain image to fit a physical display surface. + * Enabling this setting avoids smearing effects when swapchain images are simple interger + * multiples of display pixels (eg- macOS Retina, and typical of graphics apps and games), + * but may cause aliasing effects when using non-integer display scaling. + * + * The value of this parameter may be changed before creating a VkSwapchain, + * for the change to take effect. + * + * The initial value or this parameter is set by the + * MVK_CONFIG_SWAPCHAIN_MAG_FILTER_USE_NEAREST + * runtime environment variable or MoltenVK compile-time build setting. + * If neither is set, the value of this parameter defaults to true. + */ + VkBool32 swapchainMagFilterUseNearest; + + /** + * The maximum amount of time, in nanoseconds, to wait for a Metal library, function, or + * pipeline state object to be compiled and created by the Metal compiler. An internal error + * within the Metal compiler can stall the thread for up to 30 seconds. Setting this value + * limits that delay to a specified amount of time, allowing shader compilations to fail fast. + * + * The value of this parameter may be changed at any time during application runtime, + * and the changed value will immediately effect subsequent MoltenVK behaviour. + * + * The initial value or this parameter is set by the + * MVK_CONFIG_METAL_COMPILE_TIMEOUT + * runtime environment variable or MoltenVK compile-time build setting. + * If neither is set, the value of this parameter defaults to infinite. + */ + uint64_t metalCompileTimeout; + + /** + * If enabled, per-frame performance statistics are tracked, optionally logged, and can be + * retrieved via the vkGetSwapchainPerformanceMVK() function, and various performance statistics + * are tracked, logged, and can be retrieved via the vkGetPerformanceStatisticsMVK() function. + * + * The value of this parameter may be changed at any time during application runtime, + * and the changed value will immediately effect subsequent MoltenVK behaviour. + * + * The initial value or this parameter is set by the + * MVK_CONFIG_PERFORMANCE_TRACKING + * runtime environment variable or MoltenVK compile-time build setting. + * If neither is set, the value of this parameter defaults to false. + */ + VkBool32 performanceTracking; + + /** + * If non-zero, performance statistics will be periodically logged to the console, on a repeating + * cycle of this many frames per swapchain. The performanceTracking capability must also be enabled. + * + * The value of this parameter may be changed at any time during application runtime, + * and the changed value will immediately effect subsequent MoltenVK behaviour. + * + * The initial value or this parameter is set by the + * MVK_CONFIG_PERFORMANCE_LOGGING_FRAME_COUNT + * runtime environment variable or MoltenVK compile-time build setting. + * If neither is set, the value of this parameter defaults to zero. + */ + uint32_t performanceLoggingFrameCount; + + /** + * If enabled, a MoltenVK logo watermark will be rendered on top of the scene. + * This can be enabled for publicity during demos. + * + * The value of this parameter may be changed at any time during application runtime, + * and the changed value will immediately effect subsequent MoltenVK behaviour. + * + * The initial value or this parameter is set by the + * MVK_CONFIG_DISPLAY_WATERMARK + * runtime environment variable or MoltenVK compile-time build setting. + * If neither is set, the value of this parameter defaults to false. + */ + VkBool32 displayWatermark; + + /** + * Metal does not distinguish functionality between queues, which would normally mean only + * a single general-purpose queue family with multiple queues is needed. However, Vulkan + * associates command buffers with a queue family, whereas Metal associates command buffers + * with a specific Metal queue. In order to allow a Metal command buffer to be prefilled + * before is is formally submitted to a Vulkan queue, each Vulkan queue family can support + * only a single Metal queue. As a result, in order to provide parallel queue operations, + * MoltenVK provides multiple queue families, each with a single queue. + * + * If this parameter is disabled, all queue families will be advertised as having general-purpose + * graphics + compute + transfer functionality, which is how the actual Metal queues behave. + * + * If this parameter is enabled, one queue family will be advertised as having general-purpose + * graphics + compute + transfer functionality, and the remaining queue families will be advertised + * as having specialized graphics OR compute OR transfer functionality, to make it easier for some + * apps to select a queue family with the appropriate requirements. + * + * The value of this parameter must be changed before creating a VkDevice, and before + * querying a VkPhysicalDevice for queue family properties, for the change to take effect. + * + * The initial value or this parameter is set by the + * MVK_CONFIG_SPECIALIZED_QUEUE_FAMILIES + * runtime environment variable or MoltenVK compile-time build setting. + * If neither is set, the value of this parameter defaults to false. + */ + VkBool32 specializedQueueFamilies; + + /** + * If enabled, when the app creates a VkDevice from a VkPhysicalDevice (GPU) that is neither + * headless nor low-power, and is different than the GPU used by the windowing system, the + * windowing system will be forced to switch to use the GPU selected by the Vulkan app. + * When the Vulkan app is ended, the windowing system will automatically switch back to + * using the previous GPU, depending on the usage requirements of other running apps. + * + * If disabled, the Vulkan app will render using its selected GPU, and if the windowing + * system uses a different GPU, the windowing system compositor will automatically copy + * framebuffer content from the app GPU to the windowing system GPU. + * + * The value of this parmeter has no effect on systems with a single GPU, or when the + * Vulkan app creates a VkDevice from a low-power or headless VkPhysicalDevice (GPU). + * + * Switching the windowing system GPU to match the Vulkan app GPU maximizes app performance, + * because it avoids the windowing system compositor from having to copy framebuffer content + * between GPUs on each rendered frame. However, doing so forces the entire system to + * potentially switch to using a GPU that may consume more power while the app is running. + * + * Some Vulkan apps may want to render using a high-power GPU, but leave it up to the + * system window compositor to determine how best to blend content with the windowing + * system, and as a result, may want to disable this parameter. + * + * The value of this parameter must be changed before creating a VkDevice, + * for the change to take effect. + * + * The initial value or this parameter is set by the + * MVK_CONFIG_SWITCH_SYSTEM_GPU + * runtime environment variable or MoltenVK compile-time build setting. + * If neither is set, the value of this parameter defaults to true. + */ + VkBool32 switchSystemGPU; + + /** + * If enabled, arbitrary VkImageView component swizzles are supported, as defined + * in VkImageViewCreateInfo::components when creating a VkImageView. + * + * If disabled, a very limited set of VkImageView component swizzles are supported + * via format substitutions. + * + * Metal does not natively support per-texture swizzling. If this parameter is enabled + * both when a VkImageView is created, and when any pipeline that uses that VkImageView + * is compiled, VkImageView swizzling is automatically performed in the converted Metal + * shader code during all texture sampling and reading operations, regardless of whether + * a swizzle is required for the VkImageView associated with the Metal texture. + * This may result in reduced performance. + * + * The value of this parameter may be changed at any time during application runtime, + * and the changed value will immediately effect subsequent MoltenVK behaviour. + * Specifically, this parameter can be enabled when creating VkImageViews that need it, + * and compiling pipelines that use those VkImageViews, and can be disabled when creating + * VkImageViews that don't need it, and compiling pipelines that use those VkImageViews. + * + * Existing pipelines are not automatically re-compiled when this parameter is changed. + * + * An error is logged and returned during VkImageView creation if that VkImageView + * requires full image view swizzling and this feature is not enabled. An error is + * also logged when a pipeline that was not compiled with full image view swizzling + * is presented with a VkImageView that is expecting it. + * + * An error is also retuned and logged when a VkPhysicalDeviceImageFormatInfo2KHR is passed + * in a call to vkGetPhysicalDeviceImageFormatProperties2KHR() to query for an VkImageView + * format that will require full swizzling to be enabled, and this feature is not enabled. + * + * If this parameter is disabled, the following limited set of VkImageView swizzles are + * supported by MoltenVK, via automatic format substitution: + * + * Texture format Swizzle + * -------------- ------- + * VK_FORMAT_R8_UNORM ZERO, ANY, ANY, RED + * VK_FORMAT_A8_UNORM ALPHA, ANY, ANY, ZERO + * VK_FORMAT_R8G8B8A8_UNORM BLUE, GREEN, RED, ALPHA + * VK_FORMAT_R8G8B8A8_SRGB BLUE, GREEN, RED, ALPHA + * VK_FORMAT_B8G8R8A8_UNORM BLUE, GREEN, RED, ALPHA + * VK_FORMAT_B8G8R8A8_SRGB BLUE, GREEN, RED, ALPHA + * VK_FORMAT_D32_SFLOAT_S8_UINT RED, ANY, ANY, ANY (stencil only) + * VK_FORMAT_D24_UNORM_S8_UINT RED, ANY, ANY, ANY (stencil only) + * + * The initial value or this parameter is set by the + * MVK_CONFIG_FULL_IMAGE_VIEW_SWIZZLE + * runtime environment variable or MoltenVK compile-time build setting. + * If neither is set, the value of this parameter defaults to false. + */ + VkBool32 fullImageViewSwizzle; + + /** + * The index of the queue family whose presentation submissions will + * be used as the default GPU Capture Scope during debugging in Xcode. + * + * The value of this parameter must be changed before creating a VkDevice, + * for the change to take effect. + * + * The initial value or this parameter is set by the + * MVK_CONFIG_DEFAULT_GPU_CAPTURE_SCOPE_QUEUE_FAMILY_INDEX + * runtime environment variable or MoltenVK compile-time build setting. + * If neither is set, the value of this parameter defaults to zero (the first queue family). + */ + uint32_t defaultGPUCaptureScopeQueueFamilyIndex; + + /** + * The index of the queue, within the queue family identified by the + * defaultGPUCaptureScopeQueueFamilyIndex parameter, whose presentation submissions + * will be used as the default GPU Capture Scope during debugging in Xcode. + * + * The value of this parameter must be changed before creating a VkDevice, + * for the change to take effect. + * + * The initial value or this parameter is set by the + * MVK_CONFIG_DEFAULT_GPU_CAPTURE_SCOPE_QUEUE_INDEX + * runtime environment variable or MoltenVK compile-time build setting. + * If neither is set, the value of this parameter defaults to zero (the first queue). + */ + uint32_t defaultGPUCaptureScopeQueueIndex; + +} MVKConfiguration; + +/** + * Features provided by the current implementation of Metal on the current device. You can + * retrieve a copy of this structure using the vkGetPhysicalDeviceMetalFeaturesMVK() function. + * + * This structure may be extended as new features are added to MoltenVK. If you are linking to + * an implementation of MoltenVK that was compiled from a different VK_MVK_MOLTENVK_SPEC_VERSION + * than your app was, the size of this structure in your app may be larger or smaller than the + * struct in MoltenVK. See the description of the vkGetPhysicalDeviceMetalFeaturesMVK() function + * for information about how to handle this. + * + * TO SUPPORT DYNAMIC LINKING TO THIS STRUCTURE AS DESCRIBED ABOVE, THIS STRUCTURE SHOULD NOT + * BE CHANGED EXCEPT TO ADD ADDITIONAL MEMBERS ON THE END. EXISTING MEMBERS, AND THEIR ORDER, + * SHOULD NOT BE CHANGED. + */ +typedef struct { + uint32_t mslVersion; /**< The version of the Metal Shading Language available on this device. The format of the integer is MMmmpp, with two decimal digts each for Major, minor, and patch version values (eg. MSL 1.2 would appear as 010200). */ + VkBool32 indirectDrawing; /**< If true, draw calls support parameters held in a GPU buffer. */ + VkBool32 baseVertexInstanceDrawing; /**< If true, draw calls support specifiying the base vertex and instance. */ + VkBool32 dynamicMTLBuffers; /**< If true, dynamic MTLBuffers for setting vertex, fragment, and compute bytes are supported. */ + VkBool32 shaderSpecialization; /**< If true, shader specialization (aka Metal function constants) is supported. */ + VkBool32 ioSurfaces; /**< If true, VkImages can be underlaid by IOSurfaces via the vkUseIOSurfaceMVK() function, to support inter-process image transfers. */ + VkBool32 texelBuffers; /**< If true, texel buffers are supported, allowing the contents of a buffer to be interpreted as an image via a VkBufferView. */ + VkBool32 layeredRendering; /**< If true, layered rendering to multiple cube or texture array layers is supported. */ + VkBool32 presentModeImmediate; /**< If true, immediate surface present mode (VK_PRESENT_MODE_IMMEDIATE_KHR), allowing a swapchain image to be presented immediately, without waiting for the vertical sync period of the display, is supported. */ + VkBool32 stencilViews; /**< If true, stencil aspect views are supported through the MTLPixelFormatX24_Stencil8 and MTLPixelFormatX32_Stencil8 formats. */ + VkBool32 multisampleArrayTextures; /**< If true, MTLTextureType2DMultisampleArray is supported. */ + VkBool32 samplerClampToBorder; /**< If true, the border color set when creating a sampler will be respected. */ + uint32_t maxTextureDimension; /**< The maximum size of each texture dimension (width, height, or depth). */ + uint32_t maxPerStageBufferCount; /**< The total number of per-stage Metal buffers available for shader uniform content and attributes. */ + uint32_t maxPerStageTextureCount; /**< The total number of per-stage Metal textures available for shader uniform content. */ + uint32_t maxPerStageSamplerCount; /**< The total number of per-stage Metal samplers available for shader uniform content. */ + VkDeviceSize maxMTLBufferSize; /**< The max size of a MTLBuffer (in bytes). */ + VkDeviceSize mtlBufferAlignment; /**< The alignment used when allocating memory for MTLBuffers. Must be PoT. */ + VkDeviceSize maxQueryBufferSize; /**< The maximum size of an occlusion query buffer (in bytes). */ + VkDeviceSize mtlCopyBufferAlignment; /**< The alignment required during buffer copy operations (in bytes). */ + VkSampleCountFlags supportedSampleCounts; /**< A bitmask identifying the sample counts supported by the device. */ + uint32_t minSwapchainImageCount; /**< The minimum number of swapchain images that can be supported by a surface. */ + uint32_t maxSwapchainImageCount; /**< The maximum number of swapchain images that can be supported by a surface. */ + VkBool32 combinedStoreResolveAction; /**< If true, the device supports VK_ATTACHMENT_STORE_OP_STORE with a simultaneous resolve attachment. */ + VkBool32 arrayOfTextures; /**< If true, arrays of textures is supported. */ + VkBool32 arrayOfSamplers; /**< If true, arrays of texture samplers is supported. */ + MTLLanguageVersion mslVersionEnum; /**< The version of the Metal Shading Language available on this device, as a Metal enumeration. */ +} MVKPhysicalDeviceMetalFeatures; + +/** + * MoltenVK swapchain performance statistics. You can retrieve a copy of this structure using + * the vkGetSwapchainPerformanceMVK() function. + * + * This structure may be extended as new features are added to MoltenVK. If you are linking to + * an implementation of MoltenVK that was compiled from a different VK_MVK_MOLTENVK_SPEC_VERSION + * than your app was, the size of this structure in your app may be larger or smaller than the + * struct in MoltenVK. See the description of the vkGetSwapchainPerformanceMVK() function for + * information about how to handle this. + * + * TO SUPPORT DYNAMIC LINKING TO THIS STRUCTURE AS DESCRIBED ABOVE, THIS STRUCTURE SHOULD NOT + * BE CHANGED EXCEPT TO ADD ADDITIONAL MEMBERS ON THE END. EXISTING MEMBERS, AND THEIR ORDER, + * SHOULD NOT BE CHANGED. + */ +typedef struct { + double lastFrameInterval; /**< The time interval between this frame and the immediately previous frame, in milliseconds. */ + double averageFrameInterval; /**< The rolling average time interval between frames, in miliseconds. This value has less volatility than the lastFrameInterval value. */ + double averageFramesPerSecond; /**< The rolling average number of frames per second. This is simply the 1000 divided by the averageFrameInterval value. */ +} MVKSwapchainPerformance; + +/** MoltenVK performance of a particular type of activity. */ +typedef struct { + uint32_t count; /**< The number of activities of this type. */ + double averageDuration; /**< The average duration of the activity, in milliseconds. */ + double minimumDuration; /**< The minimum duration of the activity, in milliseconds. */ + double maximumDuration; /**< The maximum duration of the activity, in milliseconds. */ +} MVKPerformanceTracker; + +/** MoltenVK performance of shader compilation activities. */ +typedef struct { + MVKPerformanceTracker hashShaderCode; /** Create a hash from the incoming shader code. */ + MVKPerformanceTracker spirvToMSL; /** Convert SPIR-V to MSL source code. */ + MVKPerformanceTracker mslCompile; /** Compile MSL source code into a MTLLibrary. */ + MVKPerformanceTracker mslLoad; /** Load pre-compiled MSL code into a MTLLibrary. */ + MVKPerformanceTracker shaderLibraryFromCache; /** Retrieve a shader library from the cache, lazily creating it if needed. */ + MVKPerformanceTracker functionRetrieval; /** Retrieve a MTLFunction from a MTLLibrary. */ + MVKPerformanceTracker functionSpecialization; /** Specialize a retrieved MTLFunction. */ + MVKPerformanceTracker pipelineCompile; /** Compile MTLFunctions into a pipeline. */ +} MVKShaderCompilationPerformance; + + +/** MoltenVK performance of pipeline cache activities. */ +typedef struct { + MVKPerformanceTracker sizePipelineCache; /** Calculate the size of cache data required to write MSL to pipeline cache data stream. */ + MVKPerformanceTracker writePipelineCache; /** Write MSL to pipeline cache data stream. */ + MVKPerformanceTracker readPipelineCache; /** Read MSL from pipeline cache data stream. */ +} MVKPipelineCachePerformance; + +/** MoltenVK performance of queue activities. */ +typedef struct { + MVKPerformanceTracker mtlQueueAccess; /** Create an MTLCommmandQueue or access an existing cached instance. */ +} MVKQueuePerformance; + +/** + * MoltenVK performance. You can retrieve a copy of this structure using the vkGetPerformanceStatisticsMVK() function. + * + * This structure may be extended as new features are added to MoltenVK. If you are linking to + * an implementation of MoltenVK that was compiled from a different VK_MVK_MOLTENVK_SPEC_VERSION + * than your app was, the size of this structure in your app may be larger or smaller than the + * struct in MoltenVK. See the description of the vkGetPerformanceStatisticsMVK() function for + * information about how to handle this. + * + * TO SUPPORT DYNAMIC LINKING TO THIS STRUCTURE AS DESCRIBED ABOVE, THIS STRUCTURE SHOULD NOT + * BE CHANGED EXCEPT TO ADD ADDITIONAL MEMBERS ON THE END. EXISTING MEMBERS, AND THEIR ORDER, + * SHOULD NOT BE CHANGED. + */ +typedef struct { + MVKShaderCompilationPerformance shaderCompilation; /** Shader compilations activities. */ + MVKPipelineCachePerformance pipelineCache; /** Pipeline cache activities. */ + MVKQueuePerformance queue; /** Queue activities. */ +} MVKPerformanceStatistics; + + +#pragma mark - +#pragma mark Function types + +typedef VkResult (VKAPI_PTR *PFN_vkGetMoltenVKConfigurationMVK)(VkInstance instance, MVKConfiguration* pConfiguration, size_t* pConfigurationSize); +typedef VkResult (VKAPI_PTR *PFN_vkSetMoltenVKConfigurationMVK)(VkInstance instance, MVKConfiguration* pConfiguration, size_t* pConfigurationSize); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceMetalFeaturesMVK)(VkPhysicalDevice physicalDevice, MVKPhysicalDeviceMetalFeatures* pMetalFeatures, size_t* pMetalFeaturesSize); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainPerformanceMVK)(VkDevice device, VkSwapchainKHR swapchain, MVKSwapchainPerformance* pSwapchainPerf, size_t* pSwapchainPerfSize); +typedef VkResult (VKAPI_PTR *PFN_vkGetPerformanceStatisticsMVK)(VkDevice device, MVKPerformanceStatistics* pPerf, size_t* pPerfSize); +typedef void (VKAPI_PTR *PFN_vkGetVersionStringsMVK)(char* pMoltenVersionStringBuffer, uint32_t moltenVersionStringBufferLength, char* pVulkanVersionStringBuffer, uint32_t vulkanVersionStringBufferLength); + +#ifdef __OBJC__ +typedef void (VKAPI_PTR *PFN_vkGetMTLDeviceMVK)(VkPhysicalDevice physicalDevice, id* pMTLDevice); +typedef VkResult (VKAPI_PTR *PFN_vkSetMTLTextureMVK)(VkImage image, id mtlTexture); +typedef void (VKAPI_PTR *PFN_vkGetMTLTextureMVK)(VkImage image, id* pMTLTexture); +typedef VkResult (VKAPI_PTR *PFN_vkUseIOSurfaceMVK)(VkImage image, IOSurfaceRef ioSurface); +typedef void (VKAPI_PTR *PFN_vkGetIOSurfaceMVK)(VkImage image, IOSurfaceRef* pIOSurface); +#endif // __OBJC__ + + +#pragma mark - +#pragma mark Function prototypes + +#ifndef VK_NO_PROTOTYPES + +/** + * Populates the pConfiguration structure with the current MoltenVK configuration settings. + * + * To change a specific configuration value, call vkGetMoltenVKConfigurationMVK() to retrieve + * the current configuration, make changes, and call vkSetMoltenVKConfigurationMVK() to + * update all of the values. + * + * To be active, some configuration settings must be set before a VkDevice is created. + * See the description of the MVKConfiguration members for more information. + * + * If you are linking to an implementation of MoltenVK that was compiled from a different + * VK_MVK_MOLTENVK_SPEC_VERSION than your app was, the size of the MVKConfiguration structure + * in your app may be larger or smaller than the same struct as expected by MoltenVK. + * + * When calling this function, set the value of *pConfigurationSize to sizeof(MVKConfiguration), + * to tell MoltenVK the limit of the size of your MVKConfiguration structure. Upon return from + * this function, the value of *pConfigurationSize will hold the actual number of bytes copied + * into your passed MVKConfiguration structure, which will be the smaller of what your app + * thinks is the size of MVKConfiguration, and what MoltenVK thinks it is. This represents the + * safe access area within the structure for both MoltenVK and your app. + * + * If the size that MoltenVK expects for MVKConfiguration is different than the value passed in + * *pConfigurationSize, this function will return VK_INCOMPLETE, otherwise it will return VK_SUCCESS. + * + * Although it is not necessary, you can use this function to determine in advance the value + * that MoltenVK expects the size of MVKConfiguration to be by setting the value of pConfiguration + * to NULL. In that case, this function will set *pConfigurationSize to the size that MoltenVK + * expects MVKConfiguration to be. + */ +VKAPI_ATTR VkResult VKAPI_CALL vkGetMoltenVKConfigurationMVK( + VkInstance instance, + MVKConfiguration* pConfiguration, + size_t* pConfigurationSize); + +/** + * Sets the MoltenVK configuration settings to those found in the pConfiguration structure. + * + * To change a specific configuration value, call vkGetMoltenVKConfigurationMVK() + * to retrieve the current configuration, make changes, and call + * vkSetMoltenVKConfigurationMVK() to update all of the values. + * + * To be active, some configuration settings must be set before a VkDevice is created. + * See the description of the MVKConfiguration members for more information. + * + * If you are linking to an implementation of MoltenVK that was compiled from a different + * VK_MVK_MOLTENVK_SPEC_VERSION than your app was, the size of the MVKConfiguration structure + * in your app may be larger or smaller than the same struct as expected by MoltenVK. + * + * When calling this function, set the value of *pConfigurationSize to sizeof(MVKConfiguration), + * to tell MoltenVK the limit of the size of your MVKConfiguration structure. Upon return from + * this function, the value of *pConfigurationSize will hold the actual number of bytes copied + * out of your passed MVKConfiguration structure, which will be the smaller of what your app + * thinks is the size of MVKConfiguration, and what MoltenVK thinks it is. This represents the + * safe access area within the structure for both MoltenVK and your app. + * + * If the size that MoltenVK expects for MVKConfiguration is different than the value passed in + * *pConfigurationSize, this function will return VK_INCOMPLETE, otherwise it will return VK_SUCCESS. + * + * Although it is not necessary, you can use this function to determine in advance the value + * that MoltenVK expects the size of MVKConfiguration to be by setting the value of pConfiguration + * to NULL. In that case, this function will set *pConfigurationSize to the size that MoltenVK + * expects MVKConfiguration to be. + */ +VKAPI_ATTR VkResult VKAPI_CALL vkSetMoltenVKConfigurationMVK( + VkInstance instance, + const MVKConfiguration* pConfiguration, + size_t* pConfigurationSize); + +/** + * Populates the pMetalFeatures structure with the Metal-specific features + * supported by the specified physical device. + * + * If you are linking to an implementation of MoltenVK that was compiled from a different + * VK_MVK_MOLTENVK_SPEC_VERSION than your app was, the size of the MVKPhysicalDeviceMetalFeatures + * structure in your app may be larger or smaller than the same struct as expected by MoltenVK. + * + * When calling this function, set the value of *pMetalFeaturesSize to sizeof(MVKPhysicalDeviceMetalFeatures), + * to tell MoltenVK the limit of the size of your MVKPhysicalDeviceMetalFeatures structure. Upon return from + * this function, the value of *pMetalFeaturesSize will hold the actual number of bytes copied into your + * passed MVKPhysicalDeviceMetalFeatures structure, which will be the smaller of what your app thinks is the + * size of MVKPhysicalDeviceMetalFeatures, and what MoltenVK thinks it is. This represents the safe access + * area within the structure for both MoltenVK and your app. + * + * If the size that MoltenVK expects for MVKPhysicalDeviceMetalFeatures is different than the value passed in + * *pMetalFeaturesSize, this function will return VK_INCOMPLETE, otherwise it will return VK_SUCCESS. + * + * Although it is not necessary, you can use this function to determine in advance the value that MoltenVK + * expects the size of MVKPhysicalDeviceMetalFeatures to be by setting the value of pMetalFeatures to NULL. + * In that case, this function will set *pMetalFeaturesSize to the size that MoltenVK expects + * MVKPhysicalDeviceMetalFeatures to be. + */ +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceMetalFeaturesMVK( + VkPhysicalDevice physicalDevice, + MVKPhysicalDeviceMetalFeatures* pMetalFeatures, + size_t* pMetalFeaturesSize); + +/** + * Populates the pSwapchainPerf structure with the current performance statistics for the swapchain. + * + * If you are linking to an implementation of MoltenVK that was compiled from a different + * VK_MVK_MOLTENVK_SPEC_VERSION than your app was, the size of the MVKSwapchainPerformance + * structure in your app may be larger or smaller than the same struct as expected by MoltenVK. + * + * When calling this function, set the value of *pSwapchainPerfSize to sizeof(MVKSwapchainPerformance), + * to tell MoltenVK the limit of the size of your MVKSwapchainPerformance structure. Upon return from + * this function, the value of *pSwapchainPerfSize will hold the actual number of bytes copied into + * your passed MVKSwapchainPerformance structure, which will be the smaller of what your app thinks + * is the size of MVKSwapchainPerformance, and what MoltenVK thinks it is. This represents the safe + * access area within the structure for both MoltenVK and your app. + * + * If the size that MoltenVK expects for MVKSwapchainPerformance is different than the value passed in + * *pSwapchainPerfSize, this function will return VK_INCOMPLETE, otherwise it will return VK_SUCCESS. + * + * Although it is not necessary, you can use this function to determine in advance the value + * that MoltenVK expects the size of MVKSwapchainPerformance to be by setting the value of + * pSwapchainPerf to NULL. In that case, this function will set *pSwapchainPerfSize to the + * size that MoltenVK expects MVKSwapchainPerformance to be. + */ +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainPerformanceMVK( + VkDevice device, + VkSwapchainKHR swapchain, + MVKSwapchainPerformance* pSwapchainPerf, + size_t* pSwapchainPerfSize); + +/** + * Populates the pPerf structure with the current performance statistics for the device. + * + * If you are linking to an implementation of MoltenVK that was compiled from a different + * VK_MVK_MOLTENVK_SPEC_VERSION than your app was, the size of the MVKPerformanceStatistics + * structure in your app may be larger or smaller than the same struct as expected by MoltenVK. + * + * When calling this function, set the value of *pPerfSize to sizeof(MVKPerformanceStatistics), + * to tell MoltenVK the limit of the size of your MVKPerformanceStatistics structure. Upon return + * from this function, the value of *pPerfSize will hold the actual number of bytes copied into + * your passed MVKPerformanceStatistics structure, which will be the smaller of what your app + * thinks is the size of MVKPerformanceStatistics, and what MoltenVK thinks it is. This + * represents the safe access area within the structure for both MoltenVK and your app. + * + * If the size that MoltenVK expects for MVKPerformanceStatistics is different than the value passed + * in *pPerfSize, this function will return VK_INCOMPLETE, otherwise it will return VK_SUCCESS. + * + * Although it is not necessary, you can use this function to determine in advance the value + * that MoltenVK expects the size of MVKPerformanceStatistics to be by setting the value of + * pPerf to NULL. In that case, this function will set *pPerfSize to the size that MoltenVK + * expects MVKPerformanceStatistics to be. + */ +VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceStatisticsMVK( + VkDevice device, + MVKPerformanceStatistics* pPerf, + size_t* pPerfSize); + +/** + * Returns a human readable version of the MoltenVK and Vulkan versions. + * + * This function is provided as a convenience for reporting. Use the MVK_VERSION, + * VK_API_VERSION_1_0, and VK_HEADER_VERSION macros for programmatically accessing + * the corresponding version numbers. + */ +VKAPI_ATTR void VKAPI_CALL vkGetVersionStringsMVK( + char* pMoltenVersionStringBuffer, + uint32_t moltenVersionStringBufferLength, + char* pVulkanVersionStringBuffer, + uint32_t vulkanVersionStringBufferLength); + + +#ifdef __OBJC__ + +/** Returns, in the pMTLDevice pointer, the MTLDevice used by the VkPhysicalDevice. */ +VKAPI_ATTR void VKAPI_CALL vkGetMTLDeviceMVK( + VkPhysicalDevice physicalDevice, + id* pMTLDevice); + +/** + * Sets the VkImage to use the specified MTLTexture. + * + * Any differences in the properties of mtlTexture and this image will modify the + * properties of this image. + * + * If a MTLTexture has already been created for this image, it will be destroyed. + * + * Returns VK_SUCCESS. + */ +VKAPI_ATTR VkResult VKAPI_CALL vkSetMTLTextureMVK( + VkImage image, + id mtlTexture); + +/** Returns, in the pMTLTexture pointer, the MTLTexture currently underlaying the VkImage. */ +VKAPI_ATTR void VKAPI_CALL vkGetMTLTextureMVK( + VkImage image, + id* pMTLTexture); + +/** + * Indicates that a VkImage should use an IOSurface to underlay the Metal texture. + * + * If ioSurface is not null, it will be used as the IOSurface, and any differences + * in the properties of that IOSurface will modify the properties of this image. + * + * If ioSurface is null, this image will create and use an IOSurface + * whose properties are compatible with the properties of this image. + * + * If a MTLTexture has already been created for this image, it will be destroyed. + * + * IOSurfaces are supported on the following platforms: + * - macOS 10.11 and above + * - iOS 11.0 and above + * + * To enable IOSurface support, ensure the Deployment Target build setting + * (MACOSX_DEPLOYMENT_TARGET or IPHONEOS_DEPLOYMENT_TARGET) is set to at least + * one of the values above when compiling MoltenVK, and any app that uses MoltenVK. + * + * Returns: + * - VK_SUCCESS. + * - VK_ERROR_FEATURE_NOT_PRESENT if IOSurfaces are not supported on the platform. + * - VK_ERROR_INITIALIZATION_FAILED if ioSurface is specified and is not compatible with this VkImage. + */ +VKAPI_ATTR VkResult VKAPI_CALL vkUseIOSurfaceMVK( + VkImage image, + IOSurfaceRef ioSurface); + +/** + * Returns, in the pIOSurface pointer, the IOSurface currently underlaying the VkImage, + * as set by the useIOSurfaceMVK() function, or returns null if the VkImage is not using + * an IOSurface, or if the platform does not support IOSurfaces. + */ +VKAPI_ATTR void VKAPI_CALL vkGetIOSurfaceMVK( + VkImage image, + IOSurfaceRef* pIOSurface); + +#endif // __OBJC__ + + +#pragma mark - +#pragma mark Shaders + +/** + * Enumerates the magic number values to set in the MVKMSLSPIRVHeader when + * submitting a SPIR-V stream that contains either Metal Shading Language source + * code or Metal Shading Language compiled binary code in place of SPIR-V code. + */ +typedef enum { + kMVKMagicNumberSPIRVCode = 0x07230203, /**< SPIR-V stream contains standard SPIR-V code. */ + kMVKMagicNumberMSLSourceCode = 0x19960412, /**< SPIR-V stream contains Metal Shading Language source code. */ + kMVKMagicNumberMSLCompiledCode = 0x19981215, /**< SPIR-V stream contains Metal Shading Language compiled binary code. */ +} MVKMSLMagicNumber; + +/** + * Describes the header at the start of an SPIR-V stream, when it contains either + * Metal Shading Language source code or Metal Shading Language compiled binary code. + * + * To submit MSL source code to the vkCreateShaderModule() function in place of SPIR-V + * code, prepend a MVKMSLSPIRVHeader containing the kMVKMagicNumberMSLSourceCode magic + * number to the MSL source code. The MSL source code must be null-terminated. + * + * To submit MSL compiled binary code to the vkCreateShaderModule() function in place of + * SPIR-V code, prepend a MVKMSLSPIRVHeader containing the kMVKMagicNumberMSLCompiledCode + * magic number to the MSL compiled binary code. + * + * In both cases, the pCode element of VkShaderModuleCreateInfo should pointer to the + * location of the MVKMSLSPIRVHeader, and the MSL code should start at the byte immediately + * after the MVKMSLSPIRVHeader. + * + * The codeSize element of VkShaderModuleCreateInfo should be set to the entire size of + * the submitted code memory, including the additional sizeof(MVKMSLSPIRVHeader) bytes + * taken up by the MVKMSLSPIRVHeader, and, in the case of MSL source code, including + * the null-terminator byte. + */ +typedef uint32_t MVKMSLSPIRVHeader; + + +#endif // VK_NO_PROTOTYPES + + +#ifdef __cplusplus +} +#endif // __cplusplus + +#endif diff --git a/moltenvk/include/vulkan-portability/vk_extx_portability_subset.h b/moltenvk/include/vulkan-portability/vk_extx_portability_subset.h new file mode 100644 index 00000000..b6f7f449 --- /dev/null +++ b/moltenvk/include/vulkan-portability/vk_extx_portability_subset.h @@ -0,0 +1,76 @@ +#ifndef VK_EXTX_PORTABILITY_SUBSET_H_ +#define VK_EXTX_PORTABILITY_SUBSET_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 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. +*/ + +/* + Please Note: This extension is currently defined as "EXTX", meaning "multivendor experimental". + That means the definition of this extension is in active development, and may break compatibility + between point releases (defined as any increment of VK_EXTX_PORTABILITY_SUBSET_SPEC_VERSION). + You are free to explore the extension and provide feedback, but it is not recommended to use this + extension for shipping applications, particularly applications that require the driver implementing this + extension to be linked dynamically and potentially "dropped-in" to the application execution environment. + */ + +#include "vulkan/vulkan.h" + +#define VK_EXTX_PORTABILITY_SUBSET_SPEC_VERSION 1 +#define VK_EXTX_PORTABILITY_SUBSET_EXTENSION_NAME "VK_EXTX_portability_subset" + +#define VK_EXTX_PORTABILITY_SUBSET_EXTENSION_ID 164 +// See enum_offset() from https://www.khronos.org/registry/vulkan/specs/1.1/styleguide.html#_assigning_extension_token_values +#define VK_EXTX_PORTABILITY_SUBSET_STYPE_ID(x) \ + ((VkStructureType)(1000000000 + 1000 * (VK_EXTX_PORTABILITY_SUBSET_EXTENSION_ID - 1) + x)) +#define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_EXTX VK_EXTX_PORTABILITY_SUBSET_STYPE_ID(0) +#define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_EXTX VK_EXTX_PORTABILITY_SUBSET_STYPE_ID(1) +#define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_SUPPORT_EXTX VK_EXTX_PORTABILITY_SUBSET_STYPE_ID(2) + +typedef struct VkPhysicalDevicePortabilitySubsetFeaturesEXTX { + VkStructureType sType; + void* pNext; + VkBool32 triangleFans; + VkBool32 separateStencilMaskRef; + VkBool32 events; + VkBool32 standardImageViews; + VkBool32 samplerMipLodBias; +} VkPhysicalDevicePortabilitySubsetFeaturesEXTX; + +typedef struct VkPhysicalDevicePortabilitySubsetPropertiesEXTX { + VkStructureType sType; + void* pNext; + uint32_t minVertexInputBindingStrideAlignment; +} VkPhysicalDevicePortabilitySubsetPropertiesEXTX; + +typedef struct VkPhysicalDeviceImageViewSupportEXTX { + VkStructureType sType; + void* pNext; + VkImageViewCreateFlags flags; + VkImageViewType viewType; + VkFormat format; + VkComponentMapping components; + VkImageAspectFlags aspectMask; +} VkPhysicalDeviceImageViewSupportEXTX; + +#ifdef __cplusplus +} +#endif + +#endif // VK_EXTX_PORTABILITY_SUBSET_H_ diff --git a/moltenvk/include/vulkan/vk_icd.h b/moltenvk/include/vulkan/vk_icd.h new file mode 100644 index 00000000..b935fa17 --- /dev/null +++ b/moltenvk/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/moltenvk/include/vulkan/vk_layer.h b/moltenvk/include/vulkan/vk_layer.h new file mode 100644 index 00000000..823c88ab --- /dev/null +++ b/moltenvk/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/moltenvk/include/vulkan/vk_platform.h b/moltenvk/include/vulkan/vk_platform.h new file mode 100644 index 00000000..72892992 --- /dev/null +++ b/moltenvk/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/moltenvk/include/vulkan/vk_sdk_platform.h b/moltenvk/include/vulkan/vk_sdk_platform.h new file mode 100644 index 00000000..96d86769 --- /dev/null +++ b/moltenvk/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/moltenvk/include/vulkan/vulkan.h b/moltenvk/include/vulkan/vulkan.h new file mode 100644 index 00000000..a3be4af6 --- /dev/null +++ b/moltenvk/include/vulkan/vulkan.h @@ -0,0 +1,77 @@ +#ifndef VULKAN_H_ +#define VULKAN_H_ 1 + +/* +** Copyright (c) 2015-2019 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_FUCHSIA +#include +#include "vulkan_fuchsia.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_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/moltenvk/include/vulkan/vulkan.hpp b/moltenvk/include/vulkan/vulkan.hpp new file mode 100644 index 00000000..bb4607a6 --- /dev/null +++ b/moltenvk/include/vulkan/vulkan.hpp @@ -0,0 +1,55077 @@ +// Copyright (c) 2015-2019 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 + +#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) +# include +# include +#endif + +#if !defined(VULKAN_HPP_ASSERT) +# include +# define VULKAN_HPP_ASSERT assert +#endif + +static_assert( VK_HEADER_VERSION == 101 , "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 + +// includes through some other header +// this results in major(x) being resolved to gnu_dev_major(x) +// which is an expression in a constructor initializer list. +#if defined(major) + #undef major +#endif +#if defined(minor) + #undef minor +#endif + +// Windows defines MemoryBarrier which is deprecated and collides +// with the vk::MemoryBarrier struct. +#if defined(MemoryBarrier) + #undef MemoryBarrier +#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 inline +# 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 +{ +#if !defined(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 + + 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; + }; + + template struct isStructureChainValid { enum { value = false }; }; + + template + struct TypeList + { + using list = P; + using last = T; + }; + + template + struct extendCheck + { + static const bool valid = isStructureChainValid::value || extendCheck::valid; + }; + + template + struct extendCheck,X> + { + static const bool valid = isStructureChainValid::value; + }; + + template + struct extendCheck + { + static const bool valid = true; + }; + + 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() + { + static_assert(extendCheck::valid, "The structure chain is not valid!"); + } + + template + void link() + { + static_assert(extendCheck::valid, "The structure chain is not valid!"); + X& x = static_cast(*this); + Y& y = static_cast(*this); + x.pNext = &y; + link, Y, Z...>(); + } + + template + void linkAndCopy(StructureChain const &rhs) + { + static_assert(extendCheck::valid, "The structure chain is not valid!"); + static_cast(*this) = static_cast(rhs); + } + + template + void linkAndCopy(StructureChain const &rhs) + { + static_assert(extendCheck::valid, "The structure chain is not valid!"); + X& x = static_cast(*this); + Y& y = static_cast(*this); + x = static_cast(rhs); + x.pNext = &y; + linkAndCopy, Y, Z...>(rhs); + } + + template + void linkAndCopyElements(X const &xelem) + { + static_assert(extendCheck::valid, "The structure chain is not valid!"); + static_cast(*this) = xelem; + } + + template + void linkAndCopyElements(X const &xelem, Y const &yelem, Z const &... zelem) + { + static_assert(extendCheck::valid, "The structure chain is not valid!"); + X& x = static_cast(*this); + Y& y = static_cast(*this); + x = xelem; + x.pNext = &y; + linkAndCopyElements, Y, Z...>(yelem, zelem...); + } + }; + +#if !defined(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 + + class DispatchLoaderStatic + { + public: + VkResult vkCreateInstance( const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance ) const + { + return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance ); + } + + 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 vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo ) const + { + return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo ); + } + + void vkCmdBeginConditionalRenderingEXT( VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin ) const + { + return ::vkCmdBeginConditionalRenderingEXT( commandBuffer, pConditionalRenderingBegin ); + } + + 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 vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index ) const + { + return ::vkCmdBeginQueryIndexedEXT( commandBuffer, queryPool, query, flags, index ); + } + + void vkCmdBeginRenderPass( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents ) const + { + return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents ); + } + + void vkCmdBeginRenderPass2KHR( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo ) const + { + return ::vkCmdBeginRenderPass2KHR( commandBuffer, pRenderPassBegin, pSubpassBeginInfo ); + } + + void vkCmdBeginTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets ) const + { + return ::vkCmdBeginTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets ); + } + + 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 vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const + { + return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout ); + } + + void vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes ) const + { + return ::vkCmdBindTransformFeedbackBuffersEXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes ); + } + + 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 vkCmdBuildAccelerationStructureNV( VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset ) const + { + return ::vkCmdBuildAccelerationStructureNV( commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset ); + } + + 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 vkCmdCopyAccelerationStructureNV( VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode ) const + { + return ::vkCmdCopyAccelerationStructureNV( commandBuffer, dst, src, mode ); + } + + 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 vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride ) const + { + return ::vkCmdDrawIndirectByteCountEXT( commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride ); + } + + 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 vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const + { + return ::vkCmdDrawMeshTasksIndirectCountNV( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); + } + + void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const + { + return ::vkCmdDrawMeshTasksIndirectNV( commandBuffer, buffer, offset, drawCount, stride ); + } + + void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask ) const + { + return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask ); + } + + void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer ) const + { + return ::vkCmdEndConditionalRenderingEXT( commandBuffer ); + } + + void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer ) const + { + return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer ); + } + + void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) const + { + return ::vkCmdEndQuery( commandBuffer, queryPool, query ); + } + + void vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index ) const + { + return ::vkCmdEndQueryIndexedEXT( commandBuffer, queryPool, query, index ); + } + + void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const + { + return ::vkCmdEndRenderPass( commandBuffer ); + } + + void vkCmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo ) const + { + return ::vkCmdEndRenderPass2KHR( commandBuffer, pSubpassEndInfo ); + } + + void vkCmdEndTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets ) const + { + return ::vkCmdEndTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets ); + } + + 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 vkCmdNextSubpass2KHR( VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo ) const + { + return ::vkCmdNextSubpass2KHR( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo ); + } + + 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 vkCmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void* pCheckpointMarker ) const + { + return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker ); + } + + void vkCmdSetCoarseSampleOrderNV( VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders ) const + { + return ::vkCmdSetCoarseSampleOrderNV( commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders ); + } + + 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 vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors ) const + { + return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors ); + } + + 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 vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes ) const + { + return ::vkCmdSetViewportShadingRatePaletteNV( commandBuffer, firstViewport, viewportCount, pShadingRatePalettes ); + } + + void vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings ) const + { + return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings ); + } + + void vkCmdTraceRaysNV( VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth ) const + { + return ::vkCmdTraceRaysNV( commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth ); + } + + 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 vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery ) const + { + return ::vkCmdWriteAccelerationStructuresPropertiesNV( commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery ); + } + + 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 ); + } + + VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const + { + return ::vkEndCommandBuffer( commandBuffer ); + } + + VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags ) const + { + return ::vkResetCommandBuffer( commandBuffer, flags ); + } + + 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 ); + } + + 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 vkBindAccelerationStructureMemoryNV( VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos ) const + { + return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos ); + } + + 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 ); + } + + VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader ) const + { + return ::vkCompileDeferredNV( device, pipeline, shader ); + } + + VkResult vkCreateAccelerationStructureNV( VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure ) const + { + return ::vkCreateAccelerationStructureNV( device, pCreateInfo, pAllocator, pAccelerationStructure ); + } + + 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 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 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 ); + } + + 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 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 vkCreateRayTracingPipelinesNV( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines ) const + { + return ::vkCreateRayTracingPipelinesNV( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines ); + } + + VkResult vkCreateRenderPass( VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass ) const + { + return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass ); + } + + VkResult vkCreateRenderPass2KHR( VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass ) const + { + return ::vkCreateRenderPass2KHR( 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 ); + } + + 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 vkDestroyAccelerationStructureNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyAccelerationStructureNV( device, accelerationStructure, pAllocator ); + } + + 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 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 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 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 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 ); + } + + VkResult vkGetAccelerationStructureHandleNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData ) const + { + return ::vkGetAccelerationStructureHandleNV( device, accelerationStructure, dataSize, pData ); + } + + void vkGetAccelerationStructureMemoryRequirementsNV( VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements ) const + { + return ::vkGetAccelerationStructureMemoryRequirementsNV( device, pInfo, pMemoryRequirements ); + } + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties ) const + { + return ::vkGetAndroidHardwareBufferPropertiesANDROID( device, buffer, pProperties ); + } +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + VkDeviceAddress vkGetBufferDeviceAddressEXT( VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo ) const + { + return ::vkGetBufferDeviceAddressEXT( device, pInfo ); + } + + 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 ); + } + + VkResult vkGetCalibratedTimestampsEXT( VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation ) const + { + return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation ); + } + + 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 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*/ + + VkResult vkGetImageDrmFormatModifierPropertiesEXT( VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties ) const + { + return ::vkGetImageDrmFormatModifierPropertiesEXT( device, image, pProperties ); + } + + 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 ); + } + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer ) const + { + return ::vkGetMemoryAndroidHardwareBufferANDROID( device, pInfo, pBuffer ); + } +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + 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_KHR + VkResult vkGetMemoryWin32HandleNV( VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ) const + { + return ::vkGetMemoryWin32HandleNV( device, memory, handleType, pHandle ); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#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 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 ); + } + + VkResult vkGetRayTracingShaderGroupHandlesNV( VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData ) const + { + return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData ); + } + + 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 ); + } + + 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 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 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 ); + } + +#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 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 vkCreateDisplayPlaneSurfaceKHR( VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const + { + return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); + } + +#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*/ + +#ifdef VK_USE_PLATFORM_FUCHSIA + VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const + { + return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface ); + } +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#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_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*/ + + 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 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 vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroyInstance( instance, pAllocator ); + } + + void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator ) const + { + return ::vkDestroySurfaceKHR( instance, surface, pAllocator ); + } + + 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 ); + } + + PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char* pName ) const + { + return ::vkGetInstanceProcAddr( instance, pName ); + } + + void vkSubmitDebugUtilsMessageEXT( VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData ) const + { + return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData ); + } + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display ) const + { + return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display ); + } +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + + 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 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 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 vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains ) const + { + return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains ); + } + + VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties ) const + { + return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( physicalDevice, pPropertyCount, pProperties ); + } + + 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 ); + } + + 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*/ + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + VkResult vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay ) const + { + return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay ); + } +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + + VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const + { + return ::vkReleaseDisplayEXT( physicalDevice, display ); + } + + void vkGetQueueCheckpointDataNV( VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData ) const + { + return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData ); + } + + 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 ); + } + }; + + struct AllocationCallbacks; + + template + class ObjectDestroy + { + public: + ObjectDestroy( OwnerType owner = OwnerType(), Optional allocationCallbacks = nullptr, Dispatch const &dispatch = Dispatch() ) + : m_owner( owner ) + , m_allocationCallbacks( allocationCallbacks ) + , m_dispatch( &dispatch ) + {} + + OwnerType getOwner() const { return m_owner; } + Optional getAllocator() const { return m_allocationCallbacks; } + + protected: + template + void destroy(T t) + { + m_owner.destroy( t, m_allocationCallbacks, *m_dispatch ); + } + + private: + OwnerType m_owner; + Optional m_allocationCallbacks; + Dispatch const* m_dispatch; + }; + + class NoParent; + + template + class ObjectDestroy + { + public: + ObjectDestroy( Optional allocationCallbacks = nullptr, Dispatch const &dispatch = Dispatch() ) + : m_allocationCallbacks( allocationCallbacks ) + , m_dispatch( &dispatch ) + {} + + Optional getAllocator() const { return m_allocationCallbacks; } + + protected: + template + void destroy(T t) + { + t.destroy( m_allocationCallbacks, *m_dispatch ); + } + + private: + Optional m_allocationCallbacks; + Dispatch const* m_dispatch; + }; + + template + class ObjectFree + { + public: + ObjectFree( OwnerType owner = OwnerType(), Optional allocationCallbacks = nullptr, Dispatch const &dispatch = Dispatch() ) + : m_owner( owner ) + , m_allocationCallbacks( allocationCallbacks ) + , m_dispatch( &dispatch ) + {} + + OwnerType getOwner() const { return m_owner; } + Optional getAllocator() const { return m_allocationCallbacks; } + + protected: + template + void destroy(T t) + { + m_owner.free( t, m_allocationCallbacks, *m_dispatch ); + } + + private: + OwnerType m_owner; + Optional m_allocationCallbacks; + Dispatch const* m_dispatch; + }; + + template + class PoolFree + { + public: + PoolFree( OwnerType owner = OwnerType(), PoolType pool = PoolType(), Dispatch const &dispatch = Dispatch() ) + : m_owner( owner ) + , m_pool( pool ) + , m_dispatch( &dispatch ) + {} + + OwnerType getOwner() const { return m_owner; } + PoolType getPool() const { return m_pool; } + + protected: + template + void destroy(T t) + { + m_owner.free( m_pool, t, *m_dispatch ); + } + + private: + OwnerType m_owner; + PoolType m_pool; + Dispatch const* m_dispatch; + }; + + using Bool32 = uint32_t; + using DeviceAddress = uint64_t; + using DeviceSize = uint64_t; + using SampleMask = uint32_t; + + enum class AccelerationStructureMemoryRequirementsTypeNV + { + eObject = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV, + eBuildScratch = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV, + eUpdateScratch = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV + }; + + VULKAN_HPP_INLINE std::string to_string( AccelerationStructureMemoryRequirementsTypeNV value ) + { + switch ( value ) + { + case AccelerationStructureMemoryRequirementsTypeNV::eObject : return "Object"; + case AccelerationStructureMemoryRequirementsTypeNV::eBuildScratch : return "BuildScratch"; + case AccelerationStructureMemoryRequirementsTypeNV::eUpdateScratch : return "UpdateScratch"; + default: return "invalid"; + } + } + + enum class AccelerationStructureTypeNV + { + eTopLevel = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV, + eBottomLevel = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV + }; + + VULKAN_HPP_INLINE std::string to_string( AccelerationStructureTypeNV value ) + { + switch ( value ) + { + case AccelerationStructureTypeNV::eTopLevel : return "TopLevel"; + case AccelerationStructureTypeNV::eBottomLevel : return "BottomLevel"; + default: return "invalid"; + } + } + + enum class AttachmentLoadOp + { + eLoad = VK_ATTACHMENT_LOAD_OP_LOAD, + eClear = VK_ATTACHMENT_LOAD_OP_CLEAR, + eDontCare = VK_ATTACHMENT_LOAD_OP_DONT_CARE + }; + + 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"; + } + } + + enum class AttachmentStoreOp + { + eStore = VK_ATTACHMENT_STORE_OP_STORE, + eDontCare = VK_ATTACHMENT_STORE_OP_DONT_CARE + }; + + VULKAN_HPP_INLINE std::string to_string( AttachmentStoreOp value ) + { + switch ( value ) + { + case AttachmentStoreOp::eStore : return "Store"; + case AttachmentStoreOp::eDontCare : return "DontCare"; + default: return "invalid"; + } + } + + 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 + }; + + 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"; + } + } + + 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 + }; + + 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"; + } + } + + enum class BlendOverlapEXT + { + eUncorrelated = VK_BLEND_OVERLAP_UNCORRELATED_EXT, + eDisjoint = VK_BLEND_OVERLAP_DISJOINT_EXT, + eConjoint = VK_BLEND_OVERLAP_CONJOINT_EXT + }; + + 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"; + } + } + + 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 + }; + + 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"; + } + } + + enum class ChromaLocation + { + eCositedEven = VK_CHROMA_LOCATION_COSITED_EVEN, + eMidpoint = VK_CHROMA_LOCATION_MIDPOINT, + eCositedEvenKHR = VK_CHROMA_LOCATION_COSITED_EVEN_KHR, + eMidpointKHR = VK_CHROMA_LOCATION_MIDPOINT_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( ChromaLocation value ) + { + switch ( value ) + { + case ChromaLocation::eCositedEven : return "CositedEven"; + case ChromaLocation::eMidpoint : return "Midpoint"; + default: return "invalid"; + } + } + + enum class CoarseSampleOrderTypeNV + { + eDefault = VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV, + eCustom = VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV, + ePixelMajor = VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV, + eSampleMajor = VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV + }; + + VULKAN_HPP_INLINE std::string to_string( CoarseSampleOrderTypeNV value ) + { + switch ( value ) + { + case CoarseSampleOrderTypeNV::eDefault : return "Default"; + case CoarseSampleOrderTypeNV::eCustom : return "Custom"; + case CoarseSampleOrderTypeNV::ePixelMajor : return "PixelMajor"; + case CoarseSampleOrderTypeNV::eSampleMajor : return "SampleMajor"; + default: return "invalid"; + } + } + + 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, + eVkColorspaceSrgbNonlinear = VK_COLORSPACE_SRGB_NONLINEAR_KHR + }; + + 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"; + } + } + + enum class CommandBufferLevel + { + ePrimary = VK_COMMAND_BUFFER_LEVEL_PRIMARY, + eSecondary = VK_COMMAND_BUFFER_LEVEL_SECONDARY + }; + + VULKAN_HPP_INLINE std::string to_string( CommandBufferLevel value ) + { + switch ( value ) + { + case CommandBufferLevel::ePrimary : return "Primary"; + case CommandBufferLevel::eSecondary : return "Secondary"; + default: return "invalid"; + } + } + + 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 + }; + + 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"; + } + } + + 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 + }; + + 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"; + } + } + + enum class ComponentTypeNV + { + eFloat16 = VK_COMPONENT_TYPE_FLOAT16_NV, + eFloat32 = VK_COMPONENT_TYPE_FLOAT32_NV, + eFloat64 = VK_COMPONENT_TYPE_FLOAT64_NV, + eSint8 = VK_COMPONENT_TYPE_SINT8_NV, + eSint16 = VK_COMPONENT_TYPE_SINT16_NV, + eSint32 = VK_COMPONENT_TYPE_SINT32_NV, + eSint64 = VK_COMPONENT_TYPE_SINT64_NV, + eUint8 = VK_COMPONENT_TYPE_UINT8_NV, + eUint16 = VK_COMPONENT_TYPE_UINT16_NV, + eUint32 = VK_COMPONENT_TYPE_UINT32_NV, + eUint64 = VK_COMPONENT_TYPE_UINT64_NV + }; + + VULKAN_HPP_INLINE std::string to_string( ComponentTypeNV value ) + { + switch ( value ) + { + case ComponentTypeNV::eFloat16 : return "Float16"; + case ComponentTypeNV::eFloat32 : return "Float32"; + case ComponentTypeNV::eFloat64 : return "Float64"; + case ComponentTypeNV::eSint8 : return "Sint8"; + case ComponentTypeNV::eSint16 : return "Sint16"; + case ComponentTypeNV::eSint32 : return "Sint32"; + case ComponentTypeNV::eSint64 : return "Sint64"; + case ComponentTypeNV::eUint8 : return "Uint8"; + case ComponentTypeNV::eUint16 : return "Uint16"; + case ComponentTypeNV::eUint32 : return "Uint32"; + case ComponentTypeNV::eUint64 : return "Uint64"; + default: return "invalid"; + } + } + + enum class ConservativeRasterizationModeEXT + { + eDisabled = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT, + eOverestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, + eUnderestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT + }; + + 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"; + } + } + + enum class CopyAccelerationStructureModeNV + { + eClone = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV, + eCompact = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV + }; + + VULKAN_HPP_INLINE std::string to_string( CopyAccelerationStructureModeNV value ) + { + switch ( value ) + { + case CopyAccelerationStructureModeNV::eClone : return "Clone"; + case CopyAccelerationStructureModeNV::eCompact : return "Compact"; + default: return "invalid"; + } + } + + 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 + }; + + 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"; + } + } + + 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, + eDescriptorUpdateTemplate = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, + eAccelerationStructureNV = VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT, + eDebugReport = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, + eValidationCache = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT, + eDescriptorUpdateTemplateKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT, + eSamplerYcbcrConversionKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT + }; + + 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"; + case DebugReportObjectTypeEXT::eAccelerationStructureNV : return "AccelerationStructureNV"; + default: return "invalid"; + } + } + + 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, + eInlineUniformBlockEXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, + eAccelerationStructureNV = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV + }; + + 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"; + case DescriptorType::eInlineUniformBlockEXT : return "InlineUniformBlockEXT"; + case DescriptorType::eAccelerationStructureNV : return "AccelerationStructureNV"; + default: return "invalid"; + } + } + + enum class DescriptorUpdateTemplateType + { + eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, + ePushDescriptorsKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, + eDescriptorSetKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( DescriptorUpdateTemplateType value ) + { + switch ( value ) + { + case DescriptorUpdateTemplateType::eDescriptorSet : return "DescriptorSet"; + case DescriptorUpdateTemplateType::ePushDescriptorsKHR : return "PushDescriptorsKHR"; + default: return "invalid"; + } + } + + enum class DeviceEventTypeEXT + { + eDisplayHotplug = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( DeviceEventTypeEXT value ) + { + switch ( value ) + { + case DeviceEventTypeEXT::eDisplayHotplug : return "DisplayHotplug"; + default: return "invalid"; + } + } + + enum class DiscardRectangleModeEXT + { + eInclusive = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT, + eExclusive = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( DiscardRectangleModeEXT value ) + { + switch ( value ) + { + case DiscardRectangleModeEXT::eInclusive : return "Inclusive"; + case DiscardRectangleModeEXT::eExclusive : return "Exclusive"; + default: return "invalid"; + } + } + + enum class DisplayEventTypeEXT + { + eFirstPixelOut = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( DisplayEventTypeEXT value ) + { + switch ( value ) + { + case DisplayEventTypeEXT::eFirstPixelOut : return "FirstPixelOut"; + default: return "invalid"; + } + } + + enum class DisplayPowerStateEXT + { + eOff = VK_DISPLAY_POWER_STATE_OFF_EXT, + eSuspend = VK_DISPLAY_POWER_STATE_SUSPEND_EXT, + eOn = VK_DISPLAY_POWER_STATE_ON_EXT + }; + + 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"; + } + } + + enum class DriverIdKHR + { + eAmdProprietary = VK_DRIVER_ID_AMD_PROPRIETARY_KHR, + eAmdOpenSource = VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR, + eMesaRadv = VK_DRIVER_ID_MESA_RADV_KHR, + eNvidiaProprietary = VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR, + eIntelProprietaryWindows = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR, + eIntelOpenSourceMESA = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR, + eImaginationProprietary = VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR, + eQualcommProprietary = VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR, + eArmProprietary = VK_DRIVER_ID_ARM_PROPRIETARY_KHR, + eGooglePastel = VK_DRIVER_ID_GOOGLE_PASTEL_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( DriverIdKHR value ) + { + switch ( value ) + { + case DriverIdKHR::eAmdProprietary : return "AmdProprietary"; + case DriverIdKHR::eAmdOpenSource : return "AmdOpenSource"; + case DriverIdKHR::eMesaRadv : return "MesaRadv"; + case DriverIdKHR::eNvidiaProprietary : return "NvidiaProprietary"; + case DriverIdKHR::eIntelProprietaryWindows : return "IntelProprietaryWindows"; + case DriverIdKHR::eIntelOpenSourceMESA : return "IntelOpenSourceMESA"; + case DriverIdKHR::eImaginationProprietary : return "ImaginationProprietary"; + case DriverIdKHR::eQualcommProprietary : return "QualcommProprietary"; + case DriverIdKHR::eArmProprietary : return "ArmProprietary"; + case DriverIdKHR::eGooglePastel : return "GooglePastel"; + default: return "invalid"; + } + } + + 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, + eViewportShadingRatePaletteNV = VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV, + eViewportCoarseSampleOrderNV = VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV, + eExclusiveScissorNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV + }; + + 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"; + case DynamicState::eViewportShadingRatePaletteNV : return "ViewportShadingRatePaletteNV"; + case DynamicState::eViewportCoarseSampleOrderNV : return "ViewportCoarseSampleOrderNV"; + case DynamicState::eExclusiveScissorNV : return "ExclusiveScissorNV"; + default: return "invalid"; + } + } + + enum class Filter + { + eNearest = VK_FILTER_NEAREST, + eLinear = VK_FILTER_LINEAR, + eCubicIMG = VK_FILTER_CUBIC_IMG, + eCubicEXT = VK_FILTER_CUBIC_EXT + }; + + 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"; + } + } + + 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, + eB8G8R8G8422Unorm = VK_FORMAT_B8G8R8G8_422_UNORM, + eG8B8R83Plane420Unorm = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, + eG8B8R82Plane420Unorm = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, + eG8B8R83Plane422Unorm = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, + eG8B8R82Plane422Unorm = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, + eG8B8R83Plane444Unorm = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, + eR10X6UnormPack16 = VK_FORMAT_R10X6_UNORM_PACK16, + eR10X6G10X6Unorm2Pack16 = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, + eR10X6G10X6B10X6A10X6Unorm4Pack16 = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, + eG10X6B10X6G10X6R10X6422Unorm4Pack16 = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, + eB10X6G10X6R10X6G10X6422Unorm4Pack16 = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, + eG10X6B10X6R10X63Plane420Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, + eG10X6B10X6R10X62Plane420Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, + eG10X6B10X6R10X63Plane422Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, + eG10X6B10X6R10X62Plane422Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, + eG10X6B10X6R10X63Plane444Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, + eR12X4UnormPack16 = VK_FORMAT_R12X4_UNORM_PACK16, + eR12X4G12X4Unorm2Pack16 = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, + eR12X4G12X4B12X4A12X4Unorm4Pack16 = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, + eG12X4B12X4G12X4R12X4422Unorm4Pack16 = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, + eB12X4G12X4R12X4G12X4422Unorm4Pack16 = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, + eG12X4B12X4R12X43Plane420Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, + eG12X4B12X4R12X42Plane420Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, + eG12X4B12X4R12X43Plane422Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, + eG12X4B12X4R12X42Plane422Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, + eG12X4B12X4R12X43Plane444Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, + eG16B16G16R16422Unorm = VK_FORMAT_G16B16G16R16_422_UNORM, + eB16G16R16G16422Unorm = VK_FORMAT_B16G16R16G16_422_UNORM, + eG16B16R163Plane420Unorm = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, + eG16B16R162Plane420Unorm = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, + eG16B16R163Plane422Unorm = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, + eG16B16R162Plane422Unorm = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, + eG16B16R163Plane444Unorm = 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, + eG8B8G8R8422UnormKHR = VK_FORMAT_G8B8G8R8_422_UNORM_KHR, + eB8G8R8G8422UnormKHR = VK_FORMAT_B8G8R8G8_422_UNORM_KHR, + eG8B8R83Plane420UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR, + eG8B8R82Plane420UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR, + eG8B8R83Plane422UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR, + eG8B8R82Plane422UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR, + eG8B8R83Plane444UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR, + eR10X6UnormPack16KHR = VK_FORMAT_R10X6_UNORM_PACK16_KHR, + eR10X6G10X6Unorm2Pack16KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR, + eR10X6G10X6B10X6A10X6Unorm4Pack16KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR, + eG10X6B10X6G10X6R10X6422Unorm4Pack16KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR, + eB10X6G10X6R10X6G10X6422Unorm4Pack16KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR, + eG10X6B10X6R10X63Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR, + eG10X6B10X6R10X62Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR, + eG10X6B10X6R10X63Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR, + eG10X6B10X6R10X62Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR, + eG10X6B10X6R10X63Plane444Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR, + eR12X4UnormPack16KHR = VK_FORMAT_R12X4_UNORM_PACK16_KHR, + eR12X4G12X4Unorm2Pack16KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR, + eR12X4G12X4B12X4A12X4Unorm4Pack16KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR, + eG12X4B12X4G12X4R12X4422Unorm4Pack16KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR, + eB12X4G12X4R12X4G12X4422Unorm4Pack16KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR, + eG12X4B12X4R12X43Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR, + eG12X4B12X4R12X42Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR, + eG12X4B12X4R12X43Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR, + eG12X4B12X4R12X42Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR, + eG12X4B12X4R12X43Plane444Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR, + eG16B16G16R16422UnormKHR = VK_FORMAT_G16B16G16R16_422_UNORM_KHR, + eB16G16R16G16422UnormKHR = VK_FORMAT_B16G16R16G16_422_UNORM_KHR, + eG16B16R163Plane420UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR, + eG16B16R162Plane420UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR, + eG16B16R163Plane422UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR, + eG16B16R162Plane422UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR, + eG16B16R163Plane444UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR + }; + + 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"; + } + } + + enum class FrontFace + { + eCounterClockwise = VK_FRONT_FACE_COUNTER_CLOCKWISE, + eClockwise = VK_FRONT_FACE_CLOCKWISE + }; + + VULKAN_HPP_INLINE std::string to_string( FrontFace value ) + { + switch ( value ) + { + case FrontFace::eCounterClockwise : return "CounterClockwise"; + case FrontFace::eClockwise : return "Clockwise"; + default: return "invalid"; + } + } + + enum class GeometryTypeNV + { + eTriangles = VK_GEOMETRY_TYPE_TRIANGLES_NV, + eAabbs = VK_GEOMETRY_TYPE_AABBS_NV + }; + + VULKAN_HPP_INLINE std::string to_string( GeometryTypeNV value ) + { + switch ( value ) + { + case GeometryTypeNV::eTriangles : return "Triangles"; + case GeometryTypeNV::eAabbs : return "Aabbs"; + default: return "invalid"; + } + } + + 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, + eDepthAttachmentStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, + ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, + eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, + eShadingRateOptimalNV = VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV, + eFragmentDensityMapOptimalEXT = VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT, + eDepthReadOnlyStencilAttachmentOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR, + eDepthAttachmentStencilReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR + }; + + 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"; + case ImageLayout::eShadingRateOptimalNV : return "ShadingRateOptimalNV"; + case ImageLayout::eFragmentDensityMapOptimalEXT : return "FragmentDensityMapOptimalEXT"; + default: return "invalid"; + } + } + + enum class ImageTiling + { + eOptimal = VK_IMAGE_TILING_OPTIMAL, + eLinear = VK_IMAGE_TILING_LINEAR, + eDrmFormatModifierEXT = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( ImageTiling value ) + { + switch ( value ) + { + case ImageTiling::eOptimal : return "Optimal"; + case ImageTiling::eLinear : return "Linear"; + case ImageTiling::eDrmFormatModifierEXT : return "DrmFormatModifierEXT"; + default: return "invalid"; + } + } + + enum class ImageType + { + e1D = VK_IMAGE_TYPE_1D, + e2D = VK_IMAGE_TYPE_2D, + e3D = VK_IMAGE_TYPE_3D + }; + + 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"; + } + } + + 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 + }; + + 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"; + } + } + + enum class IndexType + { + eUint16 = VK_INDEX_TYPE_UINT16, + eUint32 = VK_INDEX_TYPE_UINT32, + eNoneNV = VK_INDEX_TYPE_NONE_NV + }; + + VULKAN_HPP_INLINE std::string to_string( IndexType value ) + { + switch ( value ) + { + case IndexType::eUint16 : return "Uint16"; + case IndexType::eUint32 : return "Uint32"; + case IndexType::eNoneNV : return "NoneNV"; + default: return "invalid"; + } + } + + 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 + }; + + 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"; + } + } + + enum class InternalAllocationType + { + eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + }; + + VULKAN_HPP_INLINE std::string to_string( InternalAllocationType value ) + { + switch ( value ) + { + case InternalAllocationType::eExecutable : return "Executable"; + default: return "invalid"; + } + } + + 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 + }; + + 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"; + } + } + + enum class MemoryOverallocationBehaviorAMD + { + eDefault = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD, + eAllowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD, + eDisallowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD + }; + + VULKAN_HPP_INLINE std::string to_string( MemoryOverallocationBehaviorAMD value ) + { + switch ( value ) + { + case MemoryOverallocationBehaviorAMD::eDefault : return "Default"; + case MemoryOverallocationBehaviorAMD::eAllowed : return "Allowed"; + case MemoryOverallocationBehaviorAMD::eDisallowed : return "Disallowed"; + default: return "invalid"; + } + } + + 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 + }; + + 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"; + } + } + + 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, + eDescriptorUpdateTemplate = 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, + eAccelerationStructureNV = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV, + eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR, + eSamplerYcbcrConversionKHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR + }; + + 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"; + case ObjectType::eAccelerationStructureNV : return "AccelerationStructureNV"; + default: return "invalid"; + } + } + + 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 + }; + + 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"; + } + } + + enum class PipelineBindPoint + { + eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS, + eCompute = VK_PIPELINE_BIND_POINT_COMPUTE, + eRayTracingNV = VK_PIPELINE_BIND_POINT_RAY_TRACING_NV + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineBindPoint value ) + { + switch ( value ) + { + case PipelineBindPoint::eGraphics : return "Graphics"; + case PipelineBindPoint::eCompute : return "Compute"; + case PipelineBindPoint::eRayTracingNV : return "RayTracingNV"; + default: return "invalid"; + } + } + + enum class PipelineCacheHeaderVersion + { + eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineCacheHeaderVersion value ) + { + switch ( value ) + { + case PipelineCacheHeaderVersion::eOne : return "One"; + default: return "invalid"; + } + } + + enum class PointClippingBehavior + { + eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, + eUserClipPlanesOnly = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, + eAllClipPlanesKHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR, + eUserClipPlanesOnlyKHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( PointClippingBehavior value ) + { + switch ( value ) + { + case PointClippingBehavior::eAllClipPlanes : return "AllClipPlanes"; + case PointClippingBehavior::eUserClipPlanesOnly : return "UserClipPlanesOnly"; + default: return "invalid"; + } + } + + 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 + }; + + 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"; + } + } + + 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 + }; + + 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"; + } + } + + 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 + }; + + 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"; + } + } + + enum class QueryType + { + eOcclusion = VK_QUERY_TYPE_OCCLUSION, + ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS, + eTimestamp = VK_QUERY_TYPE_TIMESTAMP, + eTransformFeedbackStreamEXT = VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT, + eAccelerationStructureCompactedSizeNV = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV + }; + + 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"; + case QueryType::eTransformFeedbackStreamEXT : return "TransformFeedbackStreamEXT"; + case QueryType::eAccelerationStructureCompactedSizeNV : return "AccelerationStructureCompactedSizeNV"; + default: return "invalid"; + } + } + + 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 + }; + + 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"; + } + } + + enum class RasterizationOrderAMD + { + eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD, + eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD + }; + + VULKAN_HPP_INLINE std::string to_string( RasterizationOrderAMD value ) + { + switch ( value ) + { + case RasterizationOrderAMD::eStrict : return "Strict"; + case RasterizationOrderAMD::eRelaxed : return "Relaxed"; + default: return "invalid"; + } + } + + enum class RayTracingShaderGroupTypeNV + { + eGeneral = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV, + eTrianglesHitGroup = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV, + eProceduralHitGroup = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV + }; + + VULKAN_HPP_INLINE std::string to_string( RayTracingShaderGroupTypeNV value ) + { + switch ( value ) + { + case RayTracingShaderGroupTypeNV::eGeneral : return "General"; + case RayTracingShaderGroupTypeNV::eTrianglesHitGroup : return "TrianglesHitGroup"; + case RayTracingShaderGroupTypeNV::eProceduralHitGroup : return "ProceduralHitGroup"; + default: return "invalid"; + } + } + + 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, + eErrorInvalidExternalHandle = 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, + eErrorInvalidDrmFormatModifierPlaneLayoutEXT = VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT, + eErrorFragmentationEXT = VK_ERROR_FRAGMENTATION_EXT, + eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT, + eErrorInvalidDeviceAddressEXT = VK_ERROR_INVALID_DEVICE_ADDRESS_EXT, + eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY_KHR, + eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR + }; + + 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::eErrorInvalidDrmFormatModifierPlaneLayoutEXT : return "ErrorInvalidDrmFormatModifierPlaneLayoutEXT"; + case Result::eErrorFragmentationEXT : return "ErrorFragmentationEXT"; + case Result::eErrorNotPermittedEXT : return "ErrorNotPermittedEXT"; + case Result::eErrorInvalidDeviceAddressEXT : return "ErrorInvalidDeviceAddressEXT"; + default: return "invalid"; + } + } + + 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 + }; + + 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"; + } + } + + enum class SamplerMipmapMode + { + eNearest = VK_SAMPLER_MIPMAP_MODE_NEAREST, + eLinear = VK_SAMPLER_MIPMAP_MODE_LINEAR + }; + + VULKAN_HPP_INLINE std::string to_string( SamplerMipmapMode value ) + { + switch ( value ) + { + case SamplerMipmapMode::eNearest : return "Nearest"; + case SamplerMipmapMode::eLinear : return "Linear"; + default: return "invalid"; + } + } + + 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 + }; + + 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"; + } + } + + enum class SamplerYcbcrModelConversion + { + eRgbIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, + eYcbcrIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, + eYcbcr709 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, + eYcbcr601 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, + eYcbcr2020 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, + eRgbIdentityKHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR, + eYcbcrIdentityKHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR, + eYcbcr709KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR, + eYcbcr601KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR, + eYcbcr2020KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR + }; + + 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"; + } + } + + enum class SamplerYcbcrRange + { + eItuFull = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, + eItuNarrow = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, + eItuFullKHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR, + eItuNarrowKHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( SamplerYcbcrRange value ) + { + switch ( value ) + { + case SamplerYcbcrRange::eItuFull : return "ItuFull"; + case SamplerYcbcrRange::eItuNarrow : return "ItuNarrow"; + default: return "invalid"; + } + } + + enum class ScopeNV + { + eDevice = VK_SCOPE_DEVICE_NV, + eWorkgroup = VK_SCOPE_WORKGROUP_NV, + eSubgroup = VK_SCOPE_SUBGROUP_NV, + eQueueFamily = VK_SCOPE_QUEUE_FAMILY_NV + }; + + VULKAN_HPP_INLINE std::string to_string( ScopeNV value ) + { + switch ( value ) + { + case ScopeNV::eDevice : return "Device"; + case ScopeNV::eWorkgroup : return "Workgroup"; + case ScopeNV::eSubgroup : return "Subgroup"; + case ScopeNV::eQueueFamily : return "QueueFamily"; + default: return "invalid"; + } + } + + enum class ShaderInfoTypeAMD + { + eStatistics = VK_SHADER_INFO_TYPE_STATISTICS_AMD, + eBinary = VK_SHADER_INFO_TYPE_BINARY_AMD, + eDisassembly = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD + }; + + 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"; + } + } + + enum class ShadingRatePaletteEntryNV + { + eNoInvocations = VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV, + e16InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV, + e8InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV, + e4InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV, + e2InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV, + e1InvocationPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV, + e1InvocationPer2X1Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV, + e1InvocationPer1X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV, + e1InvocationPer2X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV, + e1InvocationPer4X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV, + e1InvocationPer2X4Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV, + e1InvocationPer4X4Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV + }; + + VULKAN_HPP_INLINE std::string to_string( ShadingRatePaletteEntryNV value ) + { + switch ( value ) + { + case ShadingRatePaletteEntryNV::eNoInvocations : return "NoInvocations"; + case ShadingRatePaletteEntryNV::e16InvocationsPerPixel : return "16InvocationsPerPixel"; + case ShadingRatePaletteEntryNV::e8InvocationsPerPixel : return "8InvocationsPerPixel"; + case ShadingRatePaletteEntryNV::e4InvocationsPerPixel : return "4InvocationsPerPixel"; + case ShadingRatePaletteEntryNV::e2InvocationsPerPixel : return "2InvocationsPerPixel"; + case ShadingRatePaletteEntryNV::e1InvocationPerPixel : return "1InvocationPerPixel"; + case ShadingRatePaletteEntryNV::e1InvocationPer2X1Pixels : return "1InvocationPer2X1Pixels"; + case ShadingRatePaletteEntryNV::e1InvocationPer1X2Pixels : return "1InvocationPer1X2Pixels"; + case ShadingRatePaletteEntryNV::e1InvocationPer2X2Pixels : return "1InvocationPer2X2Pixels"; + case ShadingRatePaletteEntryNV::e1InvocationPer4X2Pixels : return "1InvocationPer4X2Pixels"; + case ShadingRatePaletteEntryNV::e1InvocationPer2X4Pixels : return "1InvocationPer2X4Pixels"; + case ShadingRatePaletteEntryNV::e1InvocationPer4X4Pixels : return "1InvocationPer4X4Pixels"; + default: return "invalid"; + } + } + + enum class SharingMode + { + eExclusive = VK_SHARING_MODE_EXCLUSIVE, + eConcurrent = VK_SHARING_MODE_CONCURRENT + }; + + VULKAN_HPP_INLINE std::string to_string( SharingMode value ) + { + switch ( value ) + { + case SharingMode::eExclusive : return "Exclusive"; + case SharingMode::eConcurrent : return "Concurrent"; + default: return "invalid"; + } + } + + 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 + }; + + 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"; + } + } + + 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, + eBindImageMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, + ePhysicalDevice16BitStorageFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, + eMemoryDedicatedRequirements = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, + eMemoryDedicatedAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, + eMemoryAllocateFlagsInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, + eDeviceGroupRenderPassBeginInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, + eDeviceGroupCommandBufferBeginInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, + eDeviceGroupSubmitInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, + eDeviceGroupBindSparseInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, + eBindBufferMemoryDeviceGroupInfo = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, + eBindImageMemoryDeviceGroupInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, + ePhysicalDeviceGroupProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, + eDeviceGroupDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, + eBufferMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, + eImageMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, + eImageSparseMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, + eMemoryRequirements2 = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, + eSparseImageMemoryRequirements2 = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, + ePhysicalDeviceFeatures2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, + ePhysicalDeviceProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, + eFormatProperties2 = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, + eImageFormatProperties2 = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, + ePhysicalDeviceImageFormatInfo2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, + eQueueFamilyProperties2 = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, + ePhysicalDeviceMemoryProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, + eSparseImageFormatProperties2 = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, + ePhysicalDeviceSparseImageFormatInfo2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, + ePhysicalDevicePointClippingProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, + eRenderPassInputAttachmentAspectCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, + eImageViewUsageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, + ePipelineTessellationDomainOriginStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, + eRenderPassMultiviewCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, + ePhysicalDeviceMultiviewFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, + ePhysicalDeviceMultiviewProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, + ePhysicalDeviceVariablePointerFeatures = 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, + eSamplerYcbcrConversionInfo = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, + eBindImagePlaneMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, + eImagePlaneMemoryRequirementsInfo = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, + ePhysicalDeviceSamplerYcbcrConversionFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, + eSamplerYcbcrConversionImageFormatProperties = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, + eDescriptorUpdateTemplateCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, + ePhysicalDeviceExternalImageFormatInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, + eExternalImageFormatProperties = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, + ePhysicalDeviceExternalBufferInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, + eExternalBufferProperties = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, + ePhysicalDeviceIdProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, + eExternalMemoryBufferCreateInfo = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, + eExternalMemoryImageCreateInfo = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, + eExportMemoryAllocateInfo = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, + ePhysicalDeviceExternalFenceInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, + eExternalFenceProperties = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, + eExportFenceCreateInfo = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, + eExportSemaphoreCreateInfo = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, + ePhysicalDeviceExternalSemaphoreInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, + eExternalSemaphoreProperties = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, + ePhysicalDeviceMaintenance3Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, + eDescriptorSetLayoutSupport = 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, + 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, + ePhysicalDeviceTransformFeedbackFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, + ePhysicalDeviceTransformFeedbackPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT, + ePipelineRasterizationStateStreamCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT, + eTextureLodGatherFormatPropertiesAMD = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD, + ePhysicalDeviceCornerSampledImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, + 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, + eImageViewAstcDecodeModeEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT, + ePhysicalDeviceAstcDecodeFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, + 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, + eCommandBufferInheritanceConditionalRenderingInfoEXT = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT, + ePhysicalDeviceConditionalRenderingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, + eConditionalRenderingBeginInfoEXT = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT, + ePhysicalDeviceFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_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, + ePhysicalDeviceDepthClipEnableFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, + ePipelineRasterizationDepthClipStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT, + eHdrMetadataEXT = VK_STRUCTURE_TYPE_HDR_METADATA_EXT, + eAttachmentDescription2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR, + eAttachmentReference2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR, + eSubpassDescription2KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR, + eSubpassDependency2KHR = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR, + eRenderPassCreateInfo2KHR = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR, + eSubpassBeginInfoKHR = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR, + eSubpassEndInfoKHR = VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR, + 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, + ePhysicalDeviceInlineUniformBlockFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, + ePhysicalDeviceInlineUniformBlockPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT, + eWriteDescriptorSetInlineUniformBlockEXT = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT, + eDescriptorPoolInlineUniformBlockCreateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_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, + eDrmFormatModifierPropertiesListEXT = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT, + eDrmFormatModifierPropertiesEXT = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT, + ePhysicalDeviceImageDrmFormatModifierInfoEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT, + eImageDrmFormatModifierListCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, + eImageDrmFormatModifierExplicitCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, + eImageDrmFormatModifierPropertiesEXT = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT, + 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, + ePipelineViewportShadingRateImageStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV, + ePhysicalDeviceShadingRateImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, + ePhysicalDeviceShadingRateImagePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV, + ePipelineViewportCoarseSampleOrderStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV, + eRayTracingPipelineCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV, + eAccelerationStructureCreateInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV, + eGeometryNV = VK_STRUCTURE_TYPE_GEOMETRY_NV, + eGeometryTrianglesNV = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV, + eGeometryAabbNV = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV, + eBindAccelerationStructureMemoryInfoNV = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV, + eWriteDescriptorSetAccelerationStructureNV = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV, + eAccelerationStructureMemoryRequirementsInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV, + ePhysicalDeviceRayTracingPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV, + eRayTracingShaderGroupCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV, + eAccelerationStructureInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV, + ePhysicalDeviceRepresentativeFragmentTestFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, + ePipelineRepresentativeFragmentTestStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV, + ePhysicalDeviceImageViewImageFormatInfoEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT, + eFilterCubicImageViewImageFormatPropertiesEXT = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, + eDeviceQueueGlobalPriorityCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT, + ePhysicalDevice8BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR, + 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, + ePhysicalDeviceShaderAtomicInt64FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR, + eCalibratedTimestampInfoEXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT, + ePhysicalDeviceShaderCorePropertiesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD, + eDeviceMemoryOverallocationCreateInfoAMD = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD, + ePhysicalDeviceVertexAttributeDivisorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, + ePipelineVertexInputDivisorStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT, + ePhysicalDeviceVertexAttributeDivisorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, + ePhysicalDeviceDriverPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR, + ePhysicalDeviceFloatControlsPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR, + ePhysicalDeviceDepthStencilResolvePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR, + eSubpassDescriptionDepthStencilResolveKHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR, + ePhysicalDeviceComputeShaderDerivativesFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, + ePhysicalDeviceMeshShaderFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, + ePhysicalDeviceMeshShaderPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV, + ePhysicalDeviceFragmentShaderBarycentricFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, + ePhysicalDeviceShaderImageFootprintFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, + ePipelineViewportExclusiveScissorStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV, + ePhysicalDeviceExclusiveScissorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, + eCheckpointDataNV = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV, + eQueueFamilyCheckpointPropertiesNV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV, + ePhysicalDeviceVulkanMemoryModelFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR, + ePhysicalDevicePciBusInfoPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT, + eImagepipeSurfaceCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA, + ePhysicalDeviceFragmentDensityMapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, + ePhysicalDeviceFragmentDensityMapPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT, + eRenderPassFragmentDensityMapCreateInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT, + ePhysicalDeviceScalarBlockLayoutFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT, + ePhysicalDeviceMemoryBudgetPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT, + ePhysicalDeviceMemoryPriorityFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, + eMemoryPriorityAllocateInfoEXT = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT, + ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, + ePhysicalDeviceBufferAddressFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT, + eBufferDeviceAddressInfoEXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT, + eBufferDeviceAddressCreateInfoEXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, + eImageStencilUsageCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT, + eValidationFeaturesEXT = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT, + ePhysicalDeviceCooperativeMatrixFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, + eCooperativeMatrixPropertiesNV = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV, + ePhysicalDeviceCooperativeMatrixPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV, + eDebugReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT, + eRenderPassMultiviewCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR, + ePhysicalDeviceMultiviewFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR, + ePhysicalDeviceMultiviewPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR, + ePhysicalDeviceFeatures2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, + ePhysicalDeviceProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, + eFormatProperties2KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR, + eImageFormatProperties2KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR, + ePhysicalDeviceImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR, + eQueueFamilyProperties2KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR, + ePhysicalDeviceMemoryProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR, + eSparseImageFormatProperties2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR, + ePhysicalDeviceSparseImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR, + eMemoryAllocateFlagsInfoKHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR, + eDeviceGroupRenderPassBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR, + eDeviceGroupCommandBufferBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR, + eDeviceGroupSubmitInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR, + eDeviceGroupBindSparseInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR, + eBindBufferMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR, + eBindImageMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR, + ePhysicalDeviceGroupPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR, + eDeviceGroupDeviceCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR, + ePhysicalDeviceExternalImageFormatInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR, + eExternalImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR, + ePhysicalDeviceExternalBufferInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR, + eExternalBufferPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR, + ePhysicalDeviceIdPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR, + eExternalMemoryBufferCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR, + eExternalMemoryImageCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR, + eExportMemoryAllocateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR, + ePhysicalDeviceExternalSemaphoreInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR, + eExternalSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR, + eExportSemaphoreCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR, + ePhysicalDevice16BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR, + eDescriptorUpdateTemplateCreateInfoKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR, + ePhysicalDeviceExternalFenceInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR, + eExternalFencePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR, + eExportFenceCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR, + ePhysicalDevicePointClippingPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR, + eRenderPassInputAttachmentAspectCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR, + eImageViewUsageCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, + ePipelineTessellationDomainOriginStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR, + ePhysicalDeviceVariablePointerFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR, + eMemoryDedicatedRequirementsKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR, + eMemoryDedicatedAllocateInfoKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR, + eBufferMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR, + eImageMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR, + eImageSparseMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR, + eMemoryRequirements2KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR, + eSparseImageMemoryRequirements2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR, + eSamplerYcbcrConversionCreateInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR, + eSamplerYcbcrConversionInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR, + eBindImagePlaneMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR, + eImagePlaneMemoryRequirementsInfoKHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR, + ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR, + eSamplerYcbcrConversionImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR, + eBindBufferMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR, + eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR, + ePhysicalDeviceMaintenance3PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR, + eDescriptorSetLayoutSupportKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR + }; + + 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::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::ePhysicalDeviceTransformFeedbackFeaturesEXT : return "PhysicalDeviceTransformFeedbackFeaturesEXT"; + case StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT : return "PhysicalDeviceTransformFeedbackPropertiesEXT"; + case StructureType::ePipelineRasterizationStateStreamCreateInfoEXT : return "PipelineRasterizationStateStreamCreateInfoEXT"; + case StructureType::eTextureLodGatherFormatPropertiesAMD : return "TextureLodGatherFormatPropertiesAMD"; + case StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV : return "PhysicalDeviceCornerSampledImageFeaturesNV"; + 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::eImageViewAstcDecodeModeEXT : return "ImageViewAstcDecodeModeEXT"; + case StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT : return "PhysicalDeviceAstcDecodeFeaturesEXT"; + 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::eCommandBufferInheritanceConditionalRenderingInfoEXT : return "CommandBufferInheritanceConditionalRenderingInfoEXT"; + case StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT : return "PhysicalDeviceConditionalRenderingFeaturesEXT"; + case StructureType::eConditionalRenderingBeginInfoEXT : return "ConditionalRenderingBeginInfoEXT"; + case StructureType::ePhysicalDeviceFloat16Int8FeaturesKHR : return "PhysicalDeviceFloat16Int8FeaturesKHR"; + 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::ePhysicalDeviceDepthClipEnableFeaturesEXT : return "PhysicalDeviceDepthClipEnableFeaturesEXT"; + case StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT : return "PipelineRasterizationDepthClipStateCreateInfoEXT"; + case StructureType::eHdrMetadataEXT : return "HdrMetadataEXT"; + case StructureType::eAttachmentDescription2KHR : return "AttachmentDescription2KHR"; + case StructureType::eAttachmentReference2KHR : return "AttachmentReference2KHR"; + case StructureType::eSubpassDescription2KHR : return "SubpassDescription2KHR"; + case StructureType::eSubpassDependency2KHR : return "SubpassDependency2KHR"; + case StructureType::eRenderPassCreateInfo2KHR : return "RenderPassCreateInfo2KHR"; + case StructureType::eSubpassBeginInfoKHR : return "SubpassBeginInfoKHR"; + case StructureType::eSubpassEndInfoKHR : return "SubpassEndInfoKHR"; + 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::ePhysicalDeviceInlineUniformBlockFeaturesEXT : return "PhysicalDeviceInlineUniformBlockFeaturesEXT"; + case StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT : return "PhysicalDeviceInlineUniformBlockPropertiesEXT"; + case StructureType::eWriteDescriptorSetInlineUniformBlockEXT : return "WriteDescriptorSetInlineUniformBlockEXT"; + case StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT : return "DescriptorPoolInlineUniformBlockCreateInfoEXT"; + 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::eDrmFormatModifierPropertiesListEXT : return "DrmFormatModifierPropertiesListEXT"; + case StructureType::eDrmFormatModifierPropertiesEXT : return "DrmFormatModifierPropertiesEXT"; + case StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT : return "PhysicalDeviceImageDrmFormatModifierInfoEXT"; + case StructureType::eImageDrmFormatModifierListCreateInfoEXT : return "ImageDrmFormatModifierListCreateInfoEXT"; + case StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT : return "ImageDrmFormatModifierExplicitCreateInfoEXT"; + case StructureType::eImageDrmFormatModifierPropertiesEXT : return "ImageDrmFormatModifierPropertiesEXT"; + 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::ePipelineViewportShadingRateImageStateCreateInfoNV : return "PipelineViewportShadingRateImageStateCreateInfoNV"; + case StructureType::ePhysicalDeviceShadingRateImageFeaturesNV : return "PhysicalDeviceShadingRateImageFeaturesNV"; + case StructureType::ePhysicalDeviceShadingRateImagePropertiesNV : return "PhysicalDeviceShadingRateImagePropertiesNV"; + case StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV : return "PipelineViewportCoarseSampleOrderStateCreateInfoNV"; + case StructureType::eRayTracingPipelineCreateInfoNV : return "RayTracingPipelineCreateInfoNV"; + case StructureType::eAccelerationStructureCreateInfoNV : return "AccelerationStructureCreateInfoNV"; + case StructureType::eGeometryNV : return "GeometryNV"; + case StructureType::eGeometryTrianglesNV : return "GeometryTrianglesNV"; + case StructureType::eGeometryAabbNV : return "GeometryAabbNV"; + case StructureType::eBindAccelerationStructureMemoryInfoNV : return "BindAccelerationStructureMemoryInfoNV"; + case StructureType::eWriteDescriptorSetAccelerationStructureNV : return "WriteDescriptorSetAccelerationStructureNV"; + case StructureType::eAccelerationStructureMemoryRequirementsInfoNV : return "AccelerationStructureMemoryRequirementsInfoNV"; + case StructureType::ePhysicalDeviceRayTracingPropertiesNV : return "PhysicalDeviceRayTracingPropertiesNV"; + case StructureType::eRayTracingShaderGroupCreateInfoNV : return "RayTracingShaderGroupCreateInfoNV"; + case StructureType::eAccelerationStructureInfoNV : return "AccelerationStructureInfoNV"; + case StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV : return "PhysicalDeviceRepresentativeFragmentTestFeaturesNV"; + case StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV : return "PipelineRepresentativeFragmentTestStateCreateInfoNV"; + case StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT : return "PhysicalDeviceImageViewImageFormatInfoEXT"; + case StructureType::eFilterCubicImageViewImageFormatPropertiesEXT : return "FilterCubicImageViewImageFormatPropertiesEXT"; + case StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT : return "DeviceQueueGlobalPriorityCreateInfoEXT"; + case StructureType::ePhysicalDevice8BitStorageFeaturesKHR : return "PhysicalDevice8BitStorageFeaturesKHR"; + case StructureType::eImportMemoryHostPointerInfoEXT : return "ImportMemoryHostPointerInfoEXT"; + case StructureType::eMemoryHostPointerPropertiesEXT : return "MemoryHostPointerPropertiesEXT"; + case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT : return "PhysicalDeviceExternalMemoryHostPropertiesEXT"; + case StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR : return "PhysicalDeviceShaderAtomicInt64FeaturesKHR"; + case StructureType::eCalibratedTimestampInfoEXT : return "CalibratedTimestampInfoEXT"; + case StructureType::ePhysicalDeviceShaderCorePropertiesAMD : return "PhysicalDeviceShaderCorePropertiesAMD"; + case StructureType::eDeviceMemoryOverallocationCreateInfoAMD : return "DeviceMemoryOverallocationCreateInfoAMD"; + case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT : return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT"; + case StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT : return "PipelineVertexInputDivisorStateCreateInfoEXT"; + case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT : return "PhysicalDeviceVertexAttributeDivisorFeaturesEXT"; + case StructureType::ePhysicalDeviceDriverPropertiesKHR : return "PhysicalDeviceDriverPropertiesKHR"; + case StructureType::ePhysicalDeviceFloatControlsPropertiesKHR : return "PhysicalDeviceFloatControlsPropertiesKHR"; + case StructureType::ePhysicalDeviceDepthStencilResolvePropertiesKHR : return "PhysicalDeviceDepthStencilResolvePropertiesKHR"; + case StructureType::eSubpassDescriptionDepthStencilResolveKHR : return "SubpassDescriptionDepthStencilResolveKHR"; + case StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV : return "PhysicalDeviceComputeShaderDerivativesFeaturesNV"; + case StructureType::ePhysicalDeviceMeshShaderFeaturesNV : return "PhysicalDeviceMeshShaderFeaturesNV"; + case StructureType::ePhysicalDeviceMeshShaderPropertiesNV : return "PhysicalDeviceMeshShaderPropertiesNV"; + case StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV : return "PhysicalDeviceFragmentShaderBarycentricFeaturesNV"; + case StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV : return "PhysicalDeviceShaderImageFootprintFeaturesNV"; + case StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV : return "PipelineViewportExclusiveScissorStateCreateInfoNV"; + case StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV : return "PhysicalDeviceExclusiveScissorFeaturesNV"; + case StructureType::eCheckpointDataNV : return "CheckpointDataNV"; + case StructureType::eQueueFamilyCheckpointPropertiesNV : return "QueueFamilyCheckpointPropertiesNV"; + case StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR : return "PhysicalDeviceVulkanMemoryModelFeaturesKHR"; + case StructureType::ePhysicalDevicePciBusInfoPropertiesEXT : return "PhysicalDevicePciBusInfoPropertiesEXT"; + case StructureType::eImagepipeSurfaceCreateInfoFUCHSIA : return "ImagepipeSurfaceCreateInfoFUCHSIA"; + case StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT : return "PhysicalDeviceFragmentDensityMapFeaturesEXT"; + case StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT : return "PhysicalDeviceFragmentDensityMapPropertiesEXT"; + case StructureType::eRenderPassFragmentDensityMapCreateInfoEXT : return "RenderPassFragmentDensityMapCreateInfoEXT"; + case StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT : return "PhysicalDeviceScalarBlockLayoutFeaturesEXT"; + case StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT : return "PhysicalDeviceMemoryBudgetPropertiesEXT"; + case StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT : return "PhysicalDeviceMemoryPriorityFeaturesEXT"; + case StructureType::eMemoryPriorityAllocateInfoEXT : return "MemoryPriorityAllocateInfoEXT"; + case StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV : return "PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV"; + case StructureType::ePhysicalDeviceBufferAddressFeaturesEXT : return "PhysicalDeviceBufferAddressFeaturesEXT"; + case StructureType::eBufferDeviceAddressInfoEXT : return "BufferDeviceAddressInfoEXT"; + case StructureType::eBufferDeviceAddressCreateInfoEXT : return "BufferDeviceAddressCreateInfoEXT"; + case StructureType::eImageStencilUsageCreateInfoEXT : return "ImageStencilUsageCreateInfoEXT"; + case StructureType::eValidationFeaturesEXT : return "ValidationFeaturesEXT"; + case StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV : return "PhysicalDeviceCooperativeMatrixFeaturesNV"; + case StructureType::eCooperativeMatrixPropertiesNV : return "CooperativeMatrixPropertiesNV"; + case StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV : return "PhysicalDeviceCooperativeMatrixPropertiesNV"; + default: return "invalid"; + } + } + + enum class SubpassContents + { + eInline = VK_SUBPASS_CONTENTS_INLINE, + eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS + }; + + VULKAN_HPP_INLINE std::string to_string( SubpassContents value ) + { + switch ( value ) + { + case SubpassContents::eInline : return "Inline"; + case SubpassContents::eSecondaryCommandBuffers : return "SecondaryCommandBuffers"; + default: return "invalid"; + } + } + + 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 + }; + + 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"; + } + } + + enum class TessellationDomainOrigin + { + eUpperLeft = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, + eLowerLeft = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, + eUpperLeftKHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR, + eLowerLeftKHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( TessellationDomainOrigin value ) + { + switch ( value ) + { + case TessellationDomainOrigin::eUpperLeft : return "UpperLeft"; + case TessellationDomainOrigin::eLowerLeft : return "LowerLeft"; + default: return "invalid"; + } + } + + enum class TimeDomainEXT + { + eDevice = VK_TIME_DOMAIN_DEVICE_EXT, + eClockMonotonic = VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT, + eClockMonotonicRaw = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT, + eQueryPerformanceCounter = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( TimeDomainEXT value ) + { + switch ( value ) + { + case TimeDomainEXT::eDevice : return "Device"; + case TimeDomainEXT::eClockMonotonic : return "ClockMonotonic"; + case TimeDomainEXT::eClockMonotonicRaw : return "ClockMonotonicRaw"; + case TimeDomainEXT::eQueryPerformanceCounter : return "QueryPerformanceCounter"; + default: return "invalid"; + } + } + + enum class ValidationCacheHeaderVersionEXT + { + eOne = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( ValidationCacheHeaderVersionEXT value ) + { + switch ( value ) + { + case ValidationCacheHeaderVersionEXT::eOne : return "One"; + default: return "invalid"; + } + } + + enum class ValidationCheckEXT + { + eAll = VK_VALIDATION_CHECK_ALL_EXT, + eShaders = VK_VALIDATION_CHECK_SHADERS_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( ValidationCheckEXT value ) + { + switch ( value ) + { + case ValidationCheckEXT::eAll : return "All"; + case ValidationCheckEXT::eShaders : return "Shaders"; + default: return "invalid"; + } + } + + enum class ValidationFeatureDisableEXT + { + eAll = VK_VALIDATION_FEATURE_DISABLE_ALL_EXT, + eShaders = VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT, + eThreadSafety = VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT, + eApiParameters = VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT, + eObjectLifetimes = VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT, + eCoreChecks = VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT, + eUniqueHandles = VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( ValidationFeatureDisableEXT value ) + { + switch ( value ) + { + case ValidationFeatureDisableEXT::eAll : return "All"; + case ValidationFeatureDisableEXT::eShaders : return "Shaders"; + case ValidationFeatureDisableEXT::eThreadSafety : return "ThreadSafety"; + case ValidationFeatureDisableEXT::eApiParameters : return "ApiParameters"; + case ValidationFeatureDisableEXT::eObjectLifetimes : return "ObjectLifetimes"; + case ValidationFeatureDisableEXT::eCoreChecks : return "CoreChecks"; + case ValidationFeatureDisableEXT::eUniqueHandles : return "UniqueHandles"; + default: return "invalid"; + } + } + + enum class ValidationFeatureEnableEXT + { + eGpuAssisted = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT, + eGpuAssistedReserveBindingSlot = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( ValidationFeatureEnableEXT value ) + { + switch ( value ) + { + case ValidationFeatureEnableEXT::eGpuAssisted : return "GpuAssisted"; + case ValidationFeatureEnableEXT::eGpuAssistedReserveBindingSlot : return "GpuAssistedReserveBindingSlot"; + default: return "invalid"; + } + } + + enum class VendorId + { + eVIV = VK_VENDOR_ID_VIV, + eVSI = VK_VENDOR_ID_VSI, + eKazan = VK_VENDOR_ID_KAZAN + }; + + 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"; + } + } + + enum class VertexInputRate + { + eVertex = VK_VERTEX_INPUT_RATE_VERTEX, + eInstance = VK_VERTEX_INPUT_RATE_INSTANCE + }; + + VULKAN_HPP_INLINE std::string to_string( VertexInputRate value ) + { + switch ( value ) + { + case VertexInputRate::eVertex : return "Vertex"; + case VertexInputRate::eInstance : return "Instance"; + default: return "invalid"; + } + } + + 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 + }; + + 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"; + } + } + + 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, + eTransformFeedbackWriteEXT = VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, + eTransformFeedbackCounterReadEXT = VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, + eTransformFeedbackCounterWriteEXT = VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT, + eConditionalRenderingReadEXT = VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT, + 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, + eShadingRateImageReadNV = VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV, + eAccelerationStructureReadNV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV, + eAccelerationStructureWriteNV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV, + eFragmentDensityMapReadEXT = VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT + }; + + 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::eTransformFeedbackWriteEXT : return "TransformFeedbackWriteEXT"; + case AccessFlagBits::eTransformFeedbackCounterReadEXT : return "TransformFeedbackCounterReadEXT"; + case AccessFlagBits::eTransformFeedbackCounterWriteEXT : return "TransformFeedbackCounterWriteEXT"; + case AccessFlagBits::eConditionalRenderingReadEXT : return "ConditionalRenderingReadEXT"; + case AccessFlagBits::eCommandProcessReadNVX : return "CommandProcessReadNVX"; + case AccessFlagBits::eCommandProcessWriteNVX : return "CommandProcessWriteNVX"; + case AccessFlagBits::eColorAttachmentReadNoncoherentEXT : return "ColorAttachmentReadNoncoherentEXT"; + case AccessFlagBits::eShadingRateImageReadNV : return "ShadingRateImageReadNV"; + case AccessFlagBits::eAccelerationStructureReadNV : return "AccelerationStructureReadNV"; + case AccessFlagBits::eAccelerationStructureWriteNV : return "AccelerationStructureWriteNV"; + case AccessFlagBits::eFragmentDensityMapReadEXT : return "FragmentDensityMapReadEXT"; + default: return "invalid"; + } + } + + 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::eTransformFeedbackWriteEXT) | VkFlags(AccessFlagBits::eTransformFeedbackCounterReadEXT) | VkFlags(AccessFlagBits::eTransformFeedbackCounterWriteEXT) | VkFlags(AccessFlagBits::eConditionalRenderingReadEXT) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT) | VkFlags(AccessFlagBits::eShadingRateImageReadNV) | VkFlags(AccessFlagBits::eAccelerationStructureReadNV) | VkFlags(AccessFlagBits::eAccelerationStructureWriteNV) | VkFlags(AccessFlagBits::eFragmentDensityMapReadEXT) + }; + }; + + 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::eTransformFeedbackWriteEXT ) result += "TransformFeedbackWriteEXT | "; + if ( value & AccessFlagBits::eTransformFeedbackCounterReadEXT ) result += "TransformFeedbackCounterReadEXT | "; + if ( value & AccessFlagBits::eTransformFeedbackCounterWriteEXT ) result += "TransformFeedbackCounterWriteEXT | "; + if ( value & AccessFlagBits::eConditionalRenderingReadEXT ) result += "ConditionalRenderingReadEXT | "; + if ( value & AccessFlagBits::eCommandProcessReadNVX ) result += "CommandProcessReadNVX | "; + if ( value & AccessFlagBits::eCommandProcessWriteNVX ) result += "CommandProcessWriteNVX | "; + if ( value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT ) result += "ColorAttachmentReadNoncoherentEXT | "; + if ( value & AccessFlagBits::eShadingRateImageReadNV ) result += "ShadingRateImageReadNV | "; + if ( value & AccessFlagBits::eAccelerationStructureReadNV ) result += "AccelerationStructureReadNV | "; + if ( value & AccessFlagBits::eAccelerationStructureWriteNV ) result += "AccelerationStructureWriteNV | "; + if ( value & AccessFlagBits::eFragmentDensityMapReadEXT ) result += "FragmentDensityMapReadEXT"; + return result; + } + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + enum class AndroidSurfaceCreateFlagBitsKHR + {}; + + VULKAN_HPP_INLINE std::string to_string( AndroidSurfaceCreateFlagBitsKHR ) + { + return "(void)"; + } + + using AndroidSurfaceCreateFlagsKHR = Flags; + + VULKAN_HPP_INLINE std::string to_string( AndroidSurfaceCreateFlagsKHR ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + enum class AttachmentDescriptionFlagBits + { + eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT + }; + + VULKAN_HPP_INLINE std::string to_string( AttachmentDescriptionFlagBits value ) + { + switch ( value ) + { + case AttachmentDescriptionFlagBits::eMayAlias : return "MayAlias"; + default: return "invalid"; + } + } + + 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) + }; + }; + + VULKAN_HPP_INLINE std::string to_string( AttachmentDescriptionFlags value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & AttachmentDescriptionFlagBits::eMayAlias ) result += "MayAlias"; + return result; + } + + 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, + eDeviceAddressCaptureReplayEXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT + }; + + 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"; + case BufferCreateFlagBits::eDeviceAddressCaptureReplayEXT : return "DeviceAddressCaptureReplayEXT"; + default: return "invalid"; + } + } + + 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) | VkFlags(BufferCreateFlagBits::eDeviceAddressCaptureReplayEXT) + }; + }; + + 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 | "; + if ( value & BufferCreateFlagBits::eDeviceAddressCaptureReplayEXT ) result += "DeviceAddressCaptureReplayEXT"; + return result; + } + + 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, + eTransformFeedbackBufferEXT = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT, + eTransformFeedbackCounterBufferEXT = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT, + eConditionalRenderingEXT = VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT, + eRayTracingNV = VK_BUFFER_USAGE_RAY_TRACING_BIT_NV, + eShaderDeviceAddressEXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT + }; + + 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"; + case BufferUsageFlagBits::eTransformFeedbackBufferEXT : return "TransformFeedbackBufferEXT"; + case BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT : return "TransformFeedbackCounterBufferEXT"; + case BufferUsageFlagBits::eConditionalRenderingEXT : return "ConditionalRenderingEXT"; + case BufferUsageFlagBits::eRayTracingNV : return "RayTracingNV"; + case BufferUsageFlagBits::eShaderDeviceAddressEXT : return "ShaderDeviceAddressEXT"; + default: return "invalid"; + } + } + + 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) | VkFlags(BufferUsageFlagBits::eTransformFeedbackBufferEXT) | VkFlags(BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT) | VkFlags(BufferUsageFlagBits::eConditionalRenderingEXT) | VkFlags(BufferUsageFlagBits::eRayTracingNV) | VkFlags(BufferUsageFlagBits::eShaderDeviceAddressEXT) + }; + }; + + 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 | "; + if ( value & BufferUsageFlagBits::eTransformFeedbackBufferEXT ) result += "TransformFeedbackBufferEXT | "; + if ( value & BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT ) result += "TransformFeedbackCounterBufferEXT | "; + if ( value & BufferUsageFlagBits::eConditionalRenderingEXT ) result += "ConditionalRenderingEXT | "; + if ( value & BufferUsageFlagBits::eRayTracingNV ) result += "RayTracingNV | "; + if ( value & BufferUsageFlagBits::eShaderDeviceAddressEXT ) result += "ShaderDeviceAddressEXT"; + return result; + } + + enum class BufferViewCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlagBits ) + { + return "(void)"; + } + + using BufferViewCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlags ) + { + return "{}"; + } + + enum class BuildAccelerationStructureFlagBitsNV + { + eAllowUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV, + eAllowCompaction = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV, + ePreferFastTrace = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV, + ePreferFastBuild = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV, + eLowMemory = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV + }; + + VULKAN_HPP_INLINE std::string to_string( BuildAccelerationStructureFlagBitsNV value ) + { + switch ( value ) + { + case BuildAccelerationStructureFlagBitsNV::eAllowUpdate : return "AllowUpdate"; + case BuildAccelerationStructureFlagBitsNV::eAllowCompaction : return "AllowCompaction"; + case BuildAccelerationStructureFlagBitsNV::ePreferFastTrace : return "PreferFastTrace"; + case BuildAccelerationStructureFlagBitsNV::ePreferFastBuild : return "PreferFastBuild"; + case BuildAccelerationStructureFlagBitsNV::eLowMemory : return "LowMemory"; + default: return "invalid"; + } + } + + using BuildAccelerationStructureFlagsNV = Flags; + + VULKAN_HPP_INLINE BuildAccelerationStructureFlagsNV operator|( BuildAccelerationStructureFlagBitsNV bit0, BuildAccelerationStructureFlagBitsNV bit1 ) + { + return BuildAccelerationStructureFlagsNV( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE BuildAccelerationStructureFlagsNV operator~( BuildAccelerationStructureFlagBitsNV bits ) + { + return ~( BuildAccelerationStructureFlagsNV( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(BuildAccelerationStructureFlagBitsNV::eAllowUpdate) | VkFlags(BuildAccelerationStructureFlagBitsNV::eAllowCompaction) | VkFlags(BuildAccelerationStructureFlagBitsNV::ePreferFastTrace) | VkFlags(BuildAccelerationStructureFlagBitsNV::ePreferFastBuild) | VkFlags(BuildAccelerationStructureFlagBitsNV::eLowMemory) + }; + }; + + VULKAN_HPP_INLINE std::string to_string( BuildAccelerationStructureFlagsNV value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & BuildAccelerationStructureFlagBitsNV::eAllowUpdate ) result += "AllowUpdate | "; + if ( value & BuildAccelerationStructureFlagBitsNV::eAllowCompaction ) result += "AllowCompaction | "; + if ( value & BuildAccelerationStructureFlagBitsNV::ePreferFastTrace ) result += "PreferFastTrace | "; + if ( value & BuildAccelerationStructureFlagBitsNV::ePreferFastBuild ) result += "PreferFastBuild | "; + if ( value & BuildAccelerationStructureFlagBitsNV::eLowMemory ) result += "LowMemory"; + return result; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + enum class CommandBufferResetFlagBits + { + eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT + }; + + VULKAN_HPP_INLINE std::string to_string( CommandBufferResetFlagBits value ) + { + switch ( value ) + { + case CommandBufferResetFlagBits::eReleaseResources : return "ReleaseResources"; + default: return "invalid"; + } + } + + 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) + }; + }; + + VULKAN_HPP_INLINE std::string to_string( CommandBufferResetFlags value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & CommandBufferResetFlagBits::eReleaseResources ) result += "ReleaseResources"; + return result; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + enum class CommandPoolResetFlagBits + { + eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT + }; + + VULKAN_HPP_INLINE std::string to_string( CommandPoolResetFlagBits value ) + { + switch ( value ) + { + case CommandPoolResetFlagBits::eReleaseResources : return "ReleaseResources"; + default: return "invalid"; + } + } + + 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) + }; + }; + + VULKAN_HPP_INLINE std::string to_string( CommandPoolResetFlags value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & CommandPoolResetFlagBits::eReleaseResources ) result += "ReleaseResources"; + return result; + } + + enum class CommandPoolTrimFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( CommandPoolTrimFlagBits ) + { + return "(void)"; + } + + using CommandPoolTrimFlags = Flags; + + using CommandPoolTrimFlagsKHR = CommandPoolTrimFlags; + + VULKAN_HPP_INLINE std::string to_string( CommandPoolTrimFlags ) + { + return "{}"; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + enum class ConditionalRenderingFlagBitsEXT + { + eInverted = VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( ConditionalRenderingFlagBitsEXT value ) + { + switch ( value ) + { + case ConditionalRenderingFlagBitsEXT::eInverted : return "Inverted"; + default: return "invalid"; + } + } + + using ConditionalRenderingFlagsEXT = Flags; + + VULKAN_HPP_INLINE ConditionalRenderingFlagsEXT operator|( ConditionalRenderingFlagBitsEXT bit0, ConditionalRenderingFlagBitsEXT bit1 ) + { + return ConditionalRenderingFlagsEXT( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ConditionalRenderingFlagsEXT operator~( ConditionalRenderingFlagBitsEXT bits ) + { + return ~( ConditionalRenderingFlagsEXT( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ConditionalRenderingFlagBitsEXT::eInverted) + }; + }; + + VULKAN_HPP_INLINE std::string to_string( ConditionalRenderingFlagsEXT value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & ConditionalRenderingFlagBitsEXT::eInverted ) result += "Inverted"; + return result; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + enum class DebugUtilsMessengerCallbackDataFlagBitsEXT + {}; + + VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCallbackDataFlagBitsEXT ) + { + return "(void)"; + } + + using DebugUtilsMessengerCallbackDataFlagsEXT = Flags; + + VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCallbackDataFlagsEXT ) + { + return "{}"; + } + + enum class DebugUtilsMessengerCreateFlagBitsEXT + {}; + + VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCreateFlagBitsEXT ) + { + return "(void)"; + } + + using DebugUtilsMessengerCreateFlagsEXT = Flags; + + VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCreateFlagsEXT ) + { + return "{}"; + } + + enum class DependencyFlagBits + { + eByRegion = VK_DEPENDENCY_BY_REGION_BIT, + eDeviceGroup = VK_DEPENDENCY_DEVICE_GROUP_BIT, + eViewLocal = VK_DEPENDENCY_VIEW_LOCAL_BIT, + eViewLocalKHR = VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR, + eDeviceGroupKHR = VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + enum class DescriptorPoolCreateFlagBits + { + eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, + eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( DescriptorPoolCreateFlagBits value ) + { + switch ( value ) + { + case DescriptorPoolCreateFlagBits::eFreeDescriptorSet : return "FreeDescriptorSet"; + case DescriptorPoolCreateFlagBits::eUpdateAfterBindEXT : return "UpdateAfterBindEXT"; + default: return "invalid"; + } + } + + 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) + }; + }; + + 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; + } + + enum class DescriptorPoolResetFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( DescriptorPoolResetFlagBits ) + { + return "(void)"; + } + + using DescriptorPoolResetFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( DescriptorPoolResetFlags ) + { + return "{}"; + } + + 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 + }; + + VULKAN_HPP_INLINE std::string to_string( DescriptorSetLayoutCreateFlagBits value ) + { + switch ( value ) + { + case DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR : return "PushDescriptorKHR"; + case DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPoolEXT : return "UpdateAfterBindPoolEXT"; + default: return "invalid"; + } + } + + 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) + }; + }; + + 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; + } + + enum class DescriptorUpdateTemplateCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( DescriptorUpdateTemplateCreateFlagBits ) + { + return "(void)"; + } + + using DescriptorUpdateTemplateCreateFlags = Flags; + + using DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags; + + VULKAN_HPP_INLINE std::string to_string( DescriptorUpdateTemplateCreateFlags ) + { + return "{}"; + } + + enum class DeviceCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( DeviceCreateFlagBits ) + { + return "(void)"; + } + + using DeviceCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( DeviceCreateFlags ) + { + return "{}"; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + enum class DeviceQueueCreateFlagBits + { + eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT + }; + + VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlagBits value ) + { + switch ( value ) + { + case DeviceQueueCreateFlagBits::eProtected : return "Protected"; + default: return "invalid"; + } + } + + 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) + }; + }; + + VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlags value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & DeviceQueueCreateFlagBits::eProtected ) result += "Protected"; + return result; + } + + enum class DisplayModeCreateFlagBitsKHR + {}; + + VULKAN_HPP_INLINE std::string to_string( DisplayModeCreateFlagBitsKHR ) + { + return "(void)"; + } + + using DisplayModeCreateFlagsKHR = Flags; + + VULKAN_HPP_INLINE std::string to_string( DisplayModeCreateFlagsKHR ) + { + return "{}"; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + enum class DisplaySurfaceCreateFlagBitsKHR + {}; + + VULKAN_HPP_INLINE std::string to_string( DisplaySurfaceCreateFlagBitsKHR ) + { + return "(void)"; + } + + using DisplaySurfaceCreateFlagsKHR = Flags; + + VULKAN_HPP_INLINE std::string to_string( DisplaySurfaceCreateFlagsKHR ) + { + return "{}"; + } + + enum class EventCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( EventCreateFlagBits ) + { + return "(void)"; + } + + using EventCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( EventCreateFlags ) + { + return "{}"; + } + + enum class ExternalFenceFeatureFlagBits + { + eExportable = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, + eImportable = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT, + eExportableKHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR, + eImportableKHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( ExternalFenceFeatureFlagBits value ) + { + switch ( value ) + { + case ExternalFenceFeatureFlagBits::eExportable : return "Exportable"; + case ExternalFenceFeatureFlagBits::eImportable : return "Importable"; + default: return "invalid"; + } + } + + 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; + + 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; + } + + enum class ExternalFenceHandleTypeFlagBits + { + eOpaqueFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, + eOpaqueWin32 = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + eOpaqueWin32Kmt = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + eSyncFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, + eOpaqueFdKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, + eOpaqueWin32KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, + eOpaqueWin32KmtKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, + eSyncFdKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR + }; + + 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"; + } + } + + 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; + + 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; + } + + enum class ExternalMemoryFeatureFlagBits + { + eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, + eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, + eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, + eDedicatedOnlyKHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR, + eExportableKHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR, + eImportableKHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR + }; + + 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"; + } + } + + 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; + + 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; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + enum class ExternalMemoryHandleTypeFlagBits + { + eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, + eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, + eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, + eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, + eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, + eD3D12Resource = 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, + eOpaqueFdKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, + eOpaqueWin32KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, + eOpaqueWin32KmtKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, + eD3D11TextureKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR, + eD3D11TextureKmtKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR, + eD3D12HeapKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR, + eD3D12ResourceKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR + }; + + 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"; + } + } + + 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; + + 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; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + enum class ExternalSemaphoreFeatureFlagBits + { + eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, + eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT, + eExportableKHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR, + eImportableKHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreFeatureFlagBits value ) + { + switch ( value ) + { + case ExternalSemaphoreFeatureFlagBits::eExportable : return "Exportable"; + case ExternalSemaphoreFeatureFlagBits::eImportable : return "Importable"; + default: return "invalid"; + } + } + + 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; + + 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; + } + + enum class ExternalSemaphoreHandleTypeFlagBits + { + eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, + eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, + eSyncFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, + eOpaqueFdKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, + eOpaqueWin32KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, + eOpaqueWin32KmtKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, + eD3D12FenceKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR, + eSyncFdKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR + }; + + 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"; + } + } + + 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; + + 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; + } + + enum class FenceCreateFlagBits + { + eSignaled = VK_FENCE_CREATE_SIGNALED_BIT + }; + + VULKAN_HPP_INLINE std::string to_string( FenceCreateFlagBits value ) + { + switch ( value ) + { + case FenceCreateFlagBits::eSignaled : return "Signaled"; + default: return "invalid"; + } + } + + 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) + }; + }; + + VULKAN_HPP_INLINE std::string to_string( FenceCreateFlags value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & FenceCreateFlagBits::eSignaled ) result += "Signaled"; + return result; + } + + enum class FenceImportFlagBits + { + eTemporary = VK_FENCE_IMPORT_TEMPORARY_BIT, + eTemporaryKHR = VK_FENCE_IMPORT_TEMPORARY_BIT_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( FenceImportFlagBits value ) + { + switch ( value ) + { + case FenceImportFlagBits::eTemporary : return "Temporary"; + default: return "invalid"; + } + } + + 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; + + VULKAN_HPP_INLINE std::string to_string( FenceImportFlags value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & FenceImportFlagBits::eTemporary ) result += "Temporary"; + return result; + } + + 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, + eTransferDst = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, + eMidpointChromaSamples = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, + eSampledImageYcbcrConversionLinearFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, + eSampledImageYcbcrConversionSeparateReconstructionFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, + eSampledImageYcbcrConversionChromaReconstructionExplicit = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, + eSampledImageYcbcrConversionChromaReconstructionExplicitForceable = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, + eDisjoint = VK_FORMAT_FEATURE_DISJOINT_BIT, + eCositedChromaSamples = 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, + eFragmentDensityMapEXT = VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT, + eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR, + eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR, + eMidpointChromaSamplesKHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR, + eSampledImageYcbcrConversionLinearFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR, + eSampledImageYcbcrConversionSeparateReconstructionFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR, + eSampledImageYcbcrConversionChromaReconstructionExplicitKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR, + eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR, + eDisjointKHR = VK_FORMAT_FEATURE_DISJOINT_BIT_KHR, + eCositedChromaSamplesKHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR, + eSampledImageFilterCubicEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT + }; + + 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"; + case FormatFeatureFlagBits::eFragmentDensityMapEXT : return "FragmentDensityMapEXT"; + default: return "invalid"; + } + } + + 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) | VkFlags(FormatFeatureFlagBits::eFragmentDensityMapEXT) + }; + }; + + 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 | "; + if ( value & FormatFeatureFlagBits::eFragmentDensityMapEXT ) result += "FragmentDensityMapEXT"; + return result; + } + + enum class FramebufferCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlagBits ) + { + return "(void)"; + } + + using FramebufferCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlags ) + { + return "{}"; + } + + enum class GeometryFlagBitsNV + { + eOpaque = VK_GEOMETRY_OPAQUE_BIT_NV, + eNoDuplicateAnyHitInvocation = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV + }; + + VULKAN_HPP_INLINE std::string to_string( GeometryFlagBitsNV value ) + { + switch ( value ) + { + case GeometryFlagBitsNV::eOpaque : return "Opaque"; + case GeometryFlagBitsNV::eNoDuplicateAnyHitInvocation : return "NoDuplicateAnyHitInvocation"; + default: return "invalid"; + } + } + + using GeometryFlagsNV = Flags; + + VULKAN_HPP_INLINE GeometryFlagsNV operator|( GeometryFlagBitsNV bit0, GeometryFlagBitsNV bit1 ) + { + return GeometryFlagsNV( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE GeometryFlagsNV operator~( GeometryFlagBitsNV bits ) + { + return ~( GeometryFlagsNV( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(GeometryFlagBitsNV::eOpaque) | VkFlags(GeometryFlagBitsNV::eNoDuplicateAnyHitInvocation) + }; + }; + + VULKAN_HPP_INLINE std::string to_string( GeometryFlagsNV value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & GeometryFlagBitsNV::eOpaque ) result += "Opaque | "; + if ( value & GeometryFlagBitsNV::eNoDuplicateAnyHitInvocation ) result += "NoDuplicateAnyHitInvocation"; + return result; + } + + enum class GeometryInstanceFlagBitsNV + { + eTriangleCullDisable = VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV, + eTriangleFrontCounterclockwise = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV, + eForceOpaque = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV, + eForceNoOpaque = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV + }; + + VULKAN_HPP_INLINE std::string to_string( GeometryInstanceFlagBitsNV value ) + { + switch ( value ) + { + case GeometryInstanceFlagBitsNV::eTriangleCullDisable : return "TriangleCullDisable"; + case GeometryInstanceFlagBitsNV::eTriangleFrontCounterclockwise : return "TriangleFrontCounterclockwise"; + case GeometryInstanceFlagBitsNV::eForceOpaque : return "ForceOpaque"; + case GeometryInstanceFlagBitsNV::eForceNoOpaque : return "ForceNoOpaque"; + default: return "invalid"; + } + } + + using GeometryInstanceFlagsNV = Flags; + + VULKAN_HPP_INLINE GeometryInstanceFlagsNV operator|( GeometryInstanceFlagBitsNV bit0, GeometryInstanceFlagBitsNV bit1 ) + { + return GeometryInstanceFlagsNV( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE GeometryInstanceFlagsNV operator~( GeometryInstanceFlagBitsNV bits ) + { + return ~( GeometryInstanceFlagsNV( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(GeometryInstanceFlagBitsNV::eTriangleCullDisable) | VkFlags(GeometryInstanceFlagBitsNV::eTriangleFrontCounterclockwise) | VkFlags(GeometryInstanceFlagBitsNV::eForceOpaque) | VkFlags(GeometryInstanceFlagBitsNV::eForceNoOpaque) + }; + }; + + VULKAN_HPP_INLINE std::string to_string( GeometryInstanceFlagsNV value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & GeometryInstanceFlagBitsNV::eTriangleCullDisable ) result += "TriangleCullDisable | "; + if ( value & GeometryInstanceFlagBitsNV::eTriangleFrontCounterclockwise ) result += "TriangleFrontCounterclockwise | "; + if ( value & GeometryInstanceFlagBitsNV::eForceOpaque ) result += "ForceOpaque | "; + if ( value & GeometryInstanceFlagBitsNV::eForceNoOpaque ) result += "ForceNoOpaque"; + return result; + } + +#ifdef VK_USE_PLATFORM_IOS_MVK + enum class IOSSurfaceCreateFlagBitsMVK + {}; + + VULKAN_HPP_INLINE std::string to_string( IOSSurfaceCreateFlagBitsMVK ) + { + return "(void)"; + } + + using IOSSurfaceCreateFlagsMVK = Flags; + + VULKAN_HPP_INLINE std::string to_string( IOSSurfaceCreateFlagsMVK ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + + 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, + ePlane1 = VK_IMAGE_ASPECT_PLANE_1_BIT, + ePlane2 = VK_IMAGE_ASPECT_PLANE_2_BIT, + eMemoryPlane0EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT, + eMemoryPlane1EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT, + eMemoryPlane2EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT, + eMemoryPlane3EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT, + ePlane0KHR = VK_IMAGE_ASPECT_PLANE_0_BIT_KHR, + ePlane1KHR = VK_IMAGE_ASPECT_PLANE_1_BIT_KHR, + ePlane2KHR = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR + }; + + 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"; + case ImageAspectFlagBits::eMemoryPlane0EXT : return "MemoryPlane0EXT"; + case ImageAspectFlagBits::eMemoryPlane1EXT : return "MemoryPlane1EXT"; + case ImageAspectFlagBits::eMemoryPlane2EXT : return "MemoryPlane2EXT"; + case ImageAspectFlagBits::eMemoryPlane3EXT : return "MemoryPlane3EXT"; + default: return "invalid"; + } + } + + 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) | VkFlags(ImageAspectFlagBits::eMemoryPlane0EXT) | VkFlags(ImageAspectFlagBits::eMemoryPlane1EXT) | VkFlags(ImageAspectFlagBits::eMemoryPlane2EXT) | VkFlags(ImageAspectFlagBits::eMemoryPlane3EXT) + }; + }; + + 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 | "; + if ( value & ImageAspectFlagBits::eMemoryPlane0EXT ) result += "MemoryPlane0EXT | "; + if ( value & ImageAspectFlagBits::eMemoryPlane1EXT ) result += "MemoryPlane1EXT | "; + if ( value & ImageAspectFlagBits::eMemoryPlane2EXT ) result += "MemoryPlane2EXT | "; + if ( value & ImageAspectFlagBits::eMemoryPlane3EXT ) result += "MemoryPlane3EXT"; + return result; + } + + 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, + eSplitInstanceBindRegions = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, + e2DArrayCompatible = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, + eBlockTexelViewCompatible = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, + eExtendedUsage = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, + eProtected = VK_IMAGE_CREATE_PROTECTED_BIT, + eDisjoint = VK_IMAGE_CREATE_DISJOINT_BIT, + eCornerSampledNV = VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV, + eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT, + eSubsampledEXT = VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT, + eSplitInstanceBindRegionsKHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR, + e2DArrayCompatibleKHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR, + eBlockTexelViewCompatibleKHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR, + eExtendedUsageKHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR, + eDisjointKHR = VK_IMAGE_CREATE_DISJOINT_BIT_KHR, + eAliasKHR = VK_IMAGE_CREATE_ALIAS_BIT_KHR + }; + + 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::eCornerSampledNV : return "CornerSampledNV"; + case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT : return "SampleLocationsCompatibleDepthEXT"; + case ImageCreateFlagBits::eSubsampledEXT : return "SubsampledEXT"; + default: return "invalid"; + } + } + + 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::eCornerSampledNV) | VkFlags(ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT) | VkFlags(ImageCreateFlagBits::eSubsampledEXT) + }; + }; + + 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::eCornerSampledNV ) result += "CornerSampledNV | "; + if ( value & ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT ) result += "SampleLocationsCompatibleDepthEXT | "; + if ( value & ImageCreateFlagBits::eSubsampledEXT ) result += "SubsampledEXT"; + return result; + } + +#ifdef VK_USE_PLATFORM_FUCHSIA + enum class ImagePipeSurfaceCreateFlagBitsFUCHSIA + {}; + + VULKAN_HPP_INLINE std::string to_string( ImagePipeSurfaceCreateFlagBitsFUCHSIA ) + { + return "(void)"; + } + + using ImagePipeSurfaceCreateFlagsFUCHSIA = Flags; + + VULKAN_HPP_INLINE std::string to_string( ImagePipeSurfaceCreateFlagsFUCHSIA ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + 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, + eShadingRateImageNV = VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, + eFragmentDensityMapEXT = VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT + }; + + 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"; + case ImageUsageFlagBits::eShadingRateImageNV : return "ShadingRateImageNV"; + case ImageUsageFlagBits::eFragmentDensityMapEXT : return "FragmentDensityMapEXT"; + default: return "invalid"; + } + } + + 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) | VkFlags(ImageUsageFlagBits::eShadingRateImageNV) | VkFlags(ImageUsageFlagBits::eFragmentDensityMapEXT) + }; + }; + + 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 | "; + if ( value & ImageUsageFlagBits::eShadingRateImageNV ) result += "ShadingRateImageNV | "; + if ( value & ImageUsageFlagBits::eFragmentDensityMapEXT ) result += "FragmentDensityMapEXT"; + return result; + } + + enum class ImageViewCreateFlagBits + { + eFragmentDensityMapDynamicEXT = VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( ImageViewCreateFlagBits value ) + { + switch ( value ) + { + case ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT : return "FragmentDensityMapDynamicEXT"; + default: return "invalid"; + } + } + + using ImageViewCreateFlags = Flags; + + VULKAN_HPP_INLINE ImageViewCreateFlags operator|( ImageViewCreateFlagBits bit0, ImageViewCreateFlagBits bit1 ) + { + return ImageViewCreateFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ImageViewCreateFlags operator~( ImageViewCreateFlagBits bits ) + { + return ~( ImageViewCreateFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT) + }; + }; + + VULKAN_HPP_INLINE std::string to_string( ImageViewCreateFlags value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT ) result += "FragmentDensityMapDynamicEXT"; + return result; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + enum class InstanceCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( InstanceCreateFlagBits ) + { + return "(void)"; + } + + using InstanceCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( InstanceCreateFlags ) + { + return "{}"; + } + +#ifdef VK_USE_PLATFORM_MACOS_MVK + enum class MacOSSurfaceCreateFlagBitsMVK + {}; + + VULKAN_HPP_INLINE std::string to_string( MacOSSurfaceCreateFlagBitsMVK ) + { + return "(void)"; + } + + using MacOSSurfaceCreateFlagsMVK = Flags; + + VULKAN_HPP_INLINE std::string to_string( MacOSSurfaceCreateFlagsMVK ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + enum class MemoryAllocateFlagBits + { + eDeviceMask = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, + eDeviceMaskKHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( MemoryAllocateFlagBits value ) + { + switch ( value ) + { + case MemoryAllocateFlagBits::eDeviceMask : return "DeviceMask"; + default: return "invalid"; + } + } + + 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; + + VULKAN_HPP_INLINE std::string to_string( MemoryAllocateFlags value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & MemoryAllocateFlagBits::eDeviceMask ) result += "DeviceMask"; + return result; + } + + enum class MemoryHeapFlagBits + { + eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT, + eMultiInstance = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, + eMultiInstanceKHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( MemoryHeapFlagBits value ) + { + switch ( value ) + { + case MemoryHeapFlagBits::eDeviceLocal : return "DeviceLocal"; + case MemoryHeapFlagBits::eMultiInstance : return "MultiInstance"; + default: return "invalid"; + } + } + + 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) + }; + }; + + 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; + } + + enum class MemoryMapFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( MemoryMapFlagBits ) + { + return "(void)"; + } + + using MemoryMapFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( MemoryMapFlags ) + { + return "{}"; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + enum class ObjectEntryUsageFlagBitsNVX + { + eGraphics = VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX, + eCompute = VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX + }; + + VULKAN_HPP_INLINE std::string to_string( ObjectEntryUsageFlagBitsNVX value ) + { + switch ( value ) + { + case ObjectEntryUsageFlagBitsNVX::eGraphics : return "Graphics"; + case ObjectEntryUsageFlagBitsNVX::eCompute : return "Compute"; + default: return "invalid"; + } + } + + 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) + }; + }; + + 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; + } + + enum class PeerMemoryFeatureFlagBits + { + eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, + eCopyDst = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, + eGenericSrc = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, + eGenericDst = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT, + eCopySrcKHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR, + eCopyDstKHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR, + eGenericSrcKHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR, + eGenericDstKHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR + }; + + 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"; + } + } + + 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; + + 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; + } + + enum class PipelineCacheCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineCacheCreateFlagBits ) + { + return "(void)"; + } + + using PipelineCacheCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineCacheCreateFlags ) + { + return "{}"; + } + + enum class PipelineColorBlendStateCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlagBits ) + { + return "(void)"; + } + + using PipelineColorBlendStateCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlags ) + { + return "{}"; + } + + enum class PipelineCoverageModulationStateCreateFlagBitsNV + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineCoverageModulationStateCreateFlagBitsNV ) + { + return "(void)"; + } + + using PipelineCoverageModulationStateCreateFlagsNV = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineCoverageModulationStateCreateFlagsNV ) + { + return "{}"; + } + + enum class PipelineCoverageToColorStateCreateFlagBitsNV + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineCoverageToColorStateCreateFlagBitsNV ) + { + return "(void)"; + } + + using PipelineCoverageToColorStateCreateFlagsNV = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineCoverageToColorStateCreateFlagsNV ) + { + return "{}"; + } + + 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, + eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE, + eDeferCompileNV = VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV, + eViewIndexFromDeviceIndexKHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR, + eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE_KHR + }; + + 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"; + case PipelineCreateFlagBits::eDeferCompileNV : return "DeferCompileNV"; + default: return "invalid"; + } + } + + 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) | VkFlags(PipelineCreateFlagBits::eDeferCompileNV) + }; + }; + + 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 | "; + if ( value & PipelineCreateFlagBits::eDeferCompileNV ) result += "DeferCompileNV"; + return result; + } + + enum class PipelineDepthStencilStateCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlagBits ) + { + return "(void)"; + } + + using PipelineDepthStencilStateCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlags ) + { + return "{}"; + } + + enum class PipelineDiscardRectangleStateCreateFlagBitsEXT + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineDiscardRectangleStateCreateFlagBitsEXT ) + { + return "(void)"; + } + + using PipelineDiscardRectangleStateCreateFlagsEXT = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineDiscardRectangleStateCreateFlagsEXT ) + { + return "{}"; + } + + enum class PipelineDynamicStateCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlagBits ) + { + return "(void)"; + } + + using PipelineDynamicStateCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlags ) + { + return "{}"; + } + + enum class PipelineInputAssemblyStateCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlagBits ) + { + return "(void)"; + } + + using PipelineInputAssemblyStateCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlags ) + { + return "{}"; + } + + enum class PipelineLayoutCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlagBits ) + { + return "(void)"; + } + + using PipelineLayoutCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlags ) + { + return "{}"; + } + + enum class PipelineMultisampleStateCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlagBits ) + { + return "(void)"; + } + + using PipelineMultisampleStateCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlags ) + { + return "{}"; + } + + enum class PipelineRasterizationConservativeStateCreateFlagBitsEXT + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationConservativeStateCreateFlagBitsEXT ) + { + return "(void)"; + } + + using PipelineRasterizationConservativeStateCreateFlagsEXT = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationConservativeStateCreateFlagsEXT ) + { + return "{}"; + } + + enum class PipelineRasterizationDepthClipStateCreateFlagBitsEXT + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationDepthClipStateCreateFlagBitsEXT ) + { + return "(void)"; + } + + using PipelineRasterizationDepthClipStateCreateFlagsEXT = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationDepthClipStateCreateFlagsEXT ) + { + return "{}"; + } + + enum class PipelineRasterizationStateCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlagBits ) + { + return "(void)"; + } + + using PipelineRasterizationStateCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlags ) + { + return "{}"; + } + + enum class PipelineRasterizationStateStreamCreateFlagBitsEXT + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateStreamCreateFlagBitsEXT ) + { + return "(void)"; + } + + using PipelineRasterizationStateStreamCreateFlagsEXT = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateStreamCreateFlagsEXT ) + { + return "{}"; + } + + enum class PipelineShaderStageCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlagBits ) + { + return "(void)"; + } + + using PipelineShaderStageCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlags ) + { + return "{}"; + } + + 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, + eTransformFeedbackEXT = VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT, + eConditionalRenderingEXT = VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT, + eCommandProcessNVX = VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX, + eShadingRateImageNV = VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV, + eRayTracingShaderNV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV, + eAccelerationStructureBuildNV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV, + eTaskShaderNV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV, + eMeshShaderNV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV, + eFragmentDensityProcessEXT = VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT + }; + + 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::eTransformFeedbackEXT : return "TransformFeedbackEXT"; + case PipelineStageFlagBits::eConditionalRenderingEXT : return "ConditionalRenderingEXT"; + case PipelineStageFlagBits::eCommandProcessNVX : return "CommandProcessNVX"; + case PipelineStageFlagBits::eShadingRateImageNV : return "ShadingRateImageNV"; + case PipelineStageFlagBits::eRayTracingShaderNV : return "RayTracingShaderNV"; + case PipelineStageFlagBits::eAccelerationStructureBuildNV : return "AccelerationStructureBuildNV"; + case PipelineStageFlagBits::eTaskShaderNV : return "TaskShaderNV"; + case PipelineStageFlagBits::eMeshShaderNV : return "MeshShaderNV"; + case PipelineStageFlagBits::eFragmentDensityProcessEXT : return "FragmentDensityProcessEXT"; + default: return "invalid"; + } + } + + 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::eTransformFeedbackEXT) | VkFlags(PipelineStageFlagBits::eConditionalRenderingEXT) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX) | VkFlags(PipelineStageFlagBits::eShadingRateImageNV) | VkFlags(PipelineStageFlagBits::eRayTracingShaderNV) | VkFlags(PipelineStageFlagBits::eAccelerationStructureBuildNV) | VkFlags(PipelineStageFlagBits::eTaskShaderNV) | VkFlags(PipelineStageFlagBits::eMeshShaderNV) | VkFlags(PipelineStageFlagBits::eFragmentDensityProcessEXT) + }; + }; + + 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::eTransformFeedbackEXT ) result += "TransformFeedbackEXT | "; + if ( value & PipelineStageFlagBits::eConditionalRenderingEXT ) result += "ConditionalRenderingEXT | "; + if ( value & PipelineStageFlagBits::eCommandProcessNVX ) result += "CommandProcessNVX | "; + if ( value & PipelineStageFlagBits::eShadingRateImageNV ) result += "ShadingRateImageNV | "; + if ( value & PipelineStageFlagBits::eRayTracingShaderNV ) result += "RayTracingShaderNV | "; + if ( value & PipelineStageFlagBits::eAccelerationStructureBuildNV ) result += "AccelerationStructureBuildNV | "; + if ( value & PipelineStageFlagBits::eTaskShaderNV ) result += "TaskShaderNV | "; + if ( value & PipelineStageFlagBits::eMeshShaderNV ) result += "MeshShaderNV | "; + if ( value & PipelineStageFlagBits::eFragmentDensityProcessEXT ) result += "FragmentDensityProcessEXT"; + return result; + } + + enum class PipelineTessellationStateCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlagBits ) + { + return "(void)"; + } + + using PipelineTessellationStateCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlags ) + { + return "{}"; + } + + enum class PipelineVertexInputStateCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlagBits ) + { + return "(void)"; + } + + using PipelineVertexInputStateCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlags ) + { + return "{}"; + } + + enum class PipelineViewportStateCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlagBits ) + { + return "(void)"; + } + + using PipelineViewportStateCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlags ) + { + return "{}"; + } + + enum class PipelineViewportSwizzleStateCreateFlagBitsNV + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineViewportSwizzleStateCreateFlagBitsNV ) + { + return "(void)"; + } + + using PipelineViewportSwizzleStateCreateFlagsNV = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineViewportSwizzleStateCreateFlagsNV ) + { + return "{}"; + } + + enum class QueryControlFlagBits + { + ePrecise = VK_QUERY_CONTROL_PRECISE_BIT + }; + + VULKAN_HPP_INLINE std::string to_string( QueryControlFlagBits value ) + { + switch ( value ) + { + case QueryControlFlagBits::ePrecise : return "Precise"; + default: return "invalid"; + } + } + + 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) + }; + }; + + VULKAN_HPP_INLINE std::string to_string( QueryControlFlags value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & QueryControlFlagBits::ePrecise ) result += "Precise"; + return result; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + enum class QueryPoolCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( QueryPoolCreateFlagBits ) + { + return "(void)"; + } + + using QueryPoolCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( QueryPoolCreateFlags ) + { + return "{}"; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + enum class RenderPassCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( RenderPassCreateFlagBits ) + { + return "(void)"; + } + + using RenderPassCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( RenderPassCreateFlags ) + { + return "{}"; + } + + enum class ResolveModeFlagBitsKHR + { + eNone = VK_RESOLVE_MODE_NONE_KHR, + eSampleZero = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR, + eAverage = VK_RESOLVE_MODE_AVERAGE_BIT_KHR, + eMin = VK_RESOLVE_MODE_MIN_BIT_KHR, + eMax = VK_RESOLVE_MODE_MAX_BIT_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( ResolveModeFlagBitsKHR value ) + { + switch ( value ) + { + case ResolveModeFlagBitsKHR::eNone : return "None"; + case ResolveModeFlagBitsKHR::eSampleZero : return "SampleZero"; + case ResolveModeFlagBitsKHR::eAverage : return "Average"; + case ResolveModeFlagBitsKHR::eMin : return "Min"; + case ResolveModeFlagBitsKHR::eMax : return "Max"; + default: return "invalid"; + } + } + + using ResolveModeFlagsKHR = Flags; + + VULKAN_HPP_INLINE ResolveModeFlagsKHR operator|( ResolveModeFlagBitsKHR bit0, ResolveModeFlagBitsKHR bit1 ) + { + return ResolveModeFlagsKHR( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ResolveModeFlagsKHR operator~( ResolveModeFlagBitsKHR bits ) + { + return ~( ResolveModeFlagsKHR( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ResolveModeFlagBitsKHR::eNone) | VkFlags(ResolveModeFlagBitsKHR::eSampleZero) | VkFlags(ResolveModeFlagBitsKHR::eAverage) | VkFlags(ResolveModeFlagBitsKHR::eMin) | VkFlags(ResolveModeFlagBitsKHR::eMax) + }; + }; + + VULKAN_HPP_INLINE std::string to_string( ResolveModeFlagsKHR value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & ResolveModeFlagBitsKHR::eNone ) result += "None | "; + if ( value & ResolveModeFlagBitsKHR::eSampleZero ) result += "SampleZero | "; + if ( value & ResolveModeFlagBitsKHR::eAverage ) result += "Average | "; + if ( value & ResolveModeFlagBitsKHR::eMin ) result += "Min | "; + if ( value & ResolveModeFlagBitsKHR::eMax ) result += "Max"; + return result; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + enum class SamplerCreateFlagBits + { + eSubsampledEXT = VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, + eSubsampledCoarseReconstructionEXT = VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( SamplerCreateFlagBits value ) + { + switch ( value ) + { + case SamplerCreateFlagBits::eSubsampledEXT : return "SubsampledEXT"; + case SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT : return "SubsampledCoarseReconstructionEXT"; + default: return "invalid"; + } + } + + using SamplerCreateFlags = Flags; + + VULKAN_HPP_INLINE SamplerCreateFlags operator|( SamplerCreateFlagBits bit0, SamplerCreateFlagBits bit1 ) + { + return SamplerCreateFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE SamplerCreateFlags operator~( SamplerCreateFlagBits bits ) + { + return ~( SamplerCreateFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(SamplerCreateFlagBits::eSubsampledEXT) | VkFlags(SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT) + }; + }; + + VULKAN_HPP_INLINE std::string to_string( SamplerCreateFlags value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & SamplerCreateFlagBits::eSubsampledEXT ) result += "SubsampledEXT | "; + if ( value & SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT ) result += "SubsampledCoarseReconstructionEXT"; + return result; + } + + enum class SemaphoreCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( SemaphoreCreateFlagBits ) + { + return "(void)"; + } + + using SemaphoreCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( SemaphoreCreateFlags ) + { + return "{}"; + } + + enum class SemaphoreImportFlagBits + { + eTemporary = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, + eTemporaryKHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( SemaphoreImportFlagBits value ) + { + switch ( value ) + { + case SemaphoreImportFlagBits::eTemporary : return "Temporary"; + default: return "invalid"; + } + } + + 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; + + VULKAN_HPP_INLINE std::string to_string( SemaphoreImportFlags value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & SemaphoreImportFlagBits::eTemporary ) result += "Temporary"; + return result; + } + + enum class ShaderModuleCreateFlagBits + {}; + + VULKAN_HPP_INLINE std::string to_string( ShaderModuleCreateFlagBits ) + { + return "(void)"; + } + + using ShaderModuleCreateFlags = Flags; + + VULKAN_HPP_INLINE std::string to_string( ShaderModuleCreateFlags ) + { + return "{}"; + } + + 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, + eRaygenNV = VK_SHADER_STAGE_RAYGEN_BIT_NV, + eAnyHitNV = VK_SHADER_STAGE_ANY_HIT_BIT_NV, + eClosestHitNV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV, + eMissNV = VK_SHADER_STAGE_MISS_BIT_NV, + eIntersectionNV = VK_SHADER_STAGE_INTERSECTION_BIT_NV, + eCallableNV = VK_SHADER_STAGE_CALLABLE_BIT_NV, + eTaskNV = VK_SHADER_STAGE_TASK_BIT_NV, + eMeshNV = VK_SHADER_STAGE_MESH_BIT_NV + }; + + 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"; + case ShaderStageFlagBits::eRaygenNV : return "RaygenNV"; + case ShaderStageFlagBits::eAnyHitNV : return "AnyHitNV"; + case ShaderStageFlagBits::eClosestHitNV : return "ClosestHitNV"; + case ShaderStageFlagBits::eMissNV : return "MissNV"; + case ShaderStageFlagBits::eIntersectionNV : return "IntersectionNV"; + case ShaderStageFlagBits::eCallableNV : return "CallableNV"; + case ShaderStageFlagBits::eTaskNV : return "TaskNV"; + case ShaderStageFlagBits::eMeshNV : return "MeshNV"; + default: return "invalid"; + } + } + + 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) | VkFlags(ShaderStageFlagBits::eRaygenNV) | VkFlags(ShaderStageFlagBits::eAnyHitNV) | VkFlags(ShaderStageFlagBits::eClosestHitNV) | VkFlags(ShaderStageFlagBits::eMissNV) | VkFlags(ShaderStageFlagBits::eIntersectionNV) | VkFlags(ShaderStageFlagBits::eCallableNV) | VkFlags(ShaderStageFlagBits::eTaskNV) | VkFlags(ShaderStageFlagBits::eMeshNV) + }; + }; + + 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 | "; + if ( value & ShaderStageFlagBits::eRaygenNV ) result += "RaygenNV | "; + if ( value & ShaderStageFlagBits::eAnyHitNV ) result += "AnyHitNV | "; + if ( value & ShaderStageFlagBits::eClosestHitNV ) result += "ClosestHitNV | "; + if ( value & ShaderStageFlagBits::eMissNV ) result += "MissNV | "; + if ( value & ShaderStageFlagBits::eIntersectionNV ) result += "IntersectionNV | "; + if ( value & ShaderStageFlagBits::eCallableNV ) result += "CallableNV | "; + if ( value & ShaderStageFlagBits::eTaskNV ) result += "TaskNV | "; + if ( value & ShaderStageFlagBits::eMeshNV ) result += "MeshNV"; + return result; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + enum class SparseMemoryBindFlagBits + { + eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT + }; + + VULKAN_HPP_INLINE std::string to_string( SparseMemoryBindFlagBits value ) + { + switch ( value ) + { + case SparseMemoryBindFlagBits::eMetadata : return "Metadata"; + default: return "invalid"; + } + } + + 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) + }; + }; + + VULKAN_HPP_INLINE std::string to_string( SparseMemoryBindFlags value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & SparseMemoryBindFlagBits::eMetadata ) result += "Metadata"; + return result; + } + + enum class StencilFaceFlagBits + { + eFront = VK_STENCIL_FACE_FRONT_BIT, + eBack = VK_STENCIL_FACE_BACK_BIT, + eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + enum class SubpassDescriptionFlagBits + { + ePerViewAttributesNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX, + ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX + }; + + VULKAN_HPP_INLINE std::string to_string( SubpassDescriptionFlagBits value ) + { + switch ( value ) + { + case SubpassDescriptionFlagBits::ePerViewAttributesNVX : return "PerViewAttributesNVX"; + case SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX : return "PerViewPositionXOnlyNVX"; + default: return "invalid"; + } + } + + 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) + }; + }; + + 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; + } + + enum class SurfaceCounterFlagBitsEXT + { + eVblank = VK_SURFACE_COUNTER_VBLANK_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( SurfaceCounterFlagBitsEXT value ) + { + switch ( value ) + { + case SurfaceCounterFlagBitsEXT::eVblank : return "Vblank"; + default: return "invalid"; + } + } + + 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) + }; + }; + + VULKAN_HPP_INLINE std::string to_string( SurfaceCounterFlagsEXT value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & SurfaceCounterFlagBitsEXT::eVblank ) result += "Vblank"; + return result; + } + + 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 + }; + + 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"; + } + } + + 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) + }; + }; + + 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; + } + + enum class SwapchainCreateFlagBitsKHR + { + eSplitInstanceBindRegions = VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR, + eProtected = VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR, + eMutableFormat = VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( SwapchainCreateFlagBitsKHR value ) + { + switch ( value ) + { + case SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions : return "SplitInstanceBindRegions"; + case SwapchainCreateFlagBitsKHR::eProtected : return "Protected"; + case SwapchainCreateFlagBitsKHR::eMutableFormat : return "MutableFormat"; + default: return "invalid"; + } + } + + 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) | VkFlags(SwapchainCreateFlagBitsKHR::eMutableFormat) + }; + }; + + 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 | "; + if ( value & SwapchainCreateFlagBitsKHR::eMutableFormat ) result += "MutableFormat"; + return result; + } + + enum class ValidationCacheCreateFlagBitsEXT + {}; + + VULKAN_HPP_INLINE std::string to_string( ValidationCacheCreateFlagBitsEXT ) + { + return "(void)"; + } + + using ValidationCacheCreateFlagsEXT = Flags; + + VULKAN_HPP_INLINE std::string to_string( ValidationCacheCreateFlagsEXT ) + { + return "{}"; + } + +#ifdef VK_USE_PLATFORM_VI_NN + enum class ViSurfaceCreateFlagBitsNN + {}; + + VULKAN_HPP_INLINE std::string to_string( ViSurfaceCreateFlagBitsNN ) + { + return "(void)"; + } + + using ViSurfaceCreateFlagsNN = Flags; + + VULKAN_HPP_INLINE std::string to_string( ViSurfaceCreateFlagsNN ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_VI_NN*/ + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + enum class WaylandSurfaceCreateFlagBitsKHR + {}; + + VULKAN_HPP_INLINE std::string to_string( WaylandSurfaceCreateFlagBitsKHR ) + { + return "(void)"; + } + + using WaylandSurfaceCreateFlagsKHR = Flags; + + VULKAN_HPP_INLINE std::string to_string( WaylandSurfaceCreateFlagsKHR ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + enum class Win32SurfaceCreateFlagBitsKHR + {}; + + VULKAN_HPP_INLINE std::string to_string( Win32SurfaceCreateFlagBitsKHR ) + { + return "(void)"; + } + + using Win32SurfaceCreateFlagsKHR = Flags; + + VULKAN_HPP_INLINE std::string to_string( Win32SurfaceCreateFlagsKHR ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_XCB_KHR + enum class XcbSurfaceCreateFlagBitsKHR + {}; + + VULKAN_HPP_INLINE std::string to_string( XcbSurfaceCreateFlagBitsKHR ) + { + return "(void)"; + } + + using XcbSurfaceCreateFlagsKHR = Flags; + + VULKAN_HPP_INLINE std::string to_string( XcbSurfaceCreateFlagsKHR ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#ifdef VK_USE_PLATFORM_XLIB_KHR + enum class XlibSurfaceCreateFlagBitsKHR + {}; + + VULKAN_HPP_INLINE std::string to_string( XlibSurfaceCreateFlagBitsKHR ) + { + return "(void)"; + } + + using XlibSurfaceCreateFlagsKHR = Flags; + + VULKAN_HPP_INLINE std::string to_string( XlibSurfaceCreateFlagsKHR ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ +} // namespace VULKAN_HPP_NAMESPACE + +namespace std +{ + template <> + struct is_error_code_enum : public true_type + {}; +} + +namespace VULKAN_HPP_NAMESPACE +{ +#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)); } + }; + + 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 + + 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()); + } + + 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 InvalidDrmFormatModifierPlaneLayoutEXTError : public SystemError + { + public: + InvalidDrmFormatModifierPlaneLayoutEXTError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) {} + InvalidDrmFormatModifierPlaneLayoutEXTError( char const * message ) + : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), 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 ) {} + }; + + class InvalidDeviceAddressEXTError : public SystemError + { + public: + InvalidDeviceAddressEXTError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorInvalidDeviceAddressEXT ), message ) {} + InvalidDeviceAddressEXTError( char const * message ) + : SystemError( make_error_code( Result::eErrorInvalidDeviceAddressEXT ), 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::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError( message ); + case Result::eErrorFragmentationEXT: throw FragmentationEXTError( message ); + case Result::eErrorNotPermittedEXT: throw NotPermittedEXTError( message ); + case Result::eErrorInvalidDeviceAddressEXT: throw InvalidDeviceAddressEXTError( message ); + default: throw SystemError( make_error_code( result ) ); + } + } +#endif + + template void ignore(T const&) {} + + 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 + ignore(message); + 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 + ignore(message); + VULKAN_HPP_ASSERT( result == Result::eSuccess ); + return ResultValue( result, std::move( 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 + ignore(message); + 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 + ignore(message); + 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 + ignore(message); + 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 AccelerationStructureCreateInfoNV; + struct AccelerationStructureInfoNV; + struct AccelerationStructureMemoryRequirementsInfoNV; + struct AcquireNextImageInfoKHR; + struct AllocationCallbacks; +#ifdef VK_USE_PLATFORM_ANDROID_KHR + struct AndroidHardwareBufferPropertiesANDROID; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ +#ifdef VK_USE_PLATFORM_ANDROID_KHR + struct AndroidSurfaceCreateInfoKHR; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + struct BindAccelerationStructureMemoryInfoNV; + struct BindBufferMemoryInfo; + using BindBufferMemoryInfoKHR = BindBufferMemoryInfo; + struct BindImageMemoryInfo; + using BindImageMemoryInfoKHR = BindImageMemoryInfo; + struct BindSparseInfo; + struct BufferCopy; + struct BufferCreateInfo; + struct BufferDeviceAddressInfoEXT; + struct BufferImageCopy; + struct BufferMemoryBarrier; + struct BufferMemoryRequirementsInfo2; + using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2; + struct BufferViewCreateInfo; + struct CalibratedTimestampInfoEXT; + struct CheckpointDataNV; + struct ClearAttachment; + union ClearColorValue; + struct ClearDepthStencilValue; + struct ClearRect; + struct CmdProcessCommandsInfoNVX; + struct CmdReserveSpaceForCommandsInfoNVX; + struct CoarseSampleOrderCustomNV; + struct CommandBufferAllocateInfo; + struct CommandBufferBeginInfo; + struct CommandPoolCreateInfo; + struct ComputePipelineCreateInfo; + struct ConditionalRenderingBeginInfoEXT; + struct CooperativeMatrixPropertiesNV; + struct CopyDescriptorSet; + struct DebugMarkerMarkerInfoEXT; + struct DebugMarkerObjectNameInfoEXT; + struct DebugMarkerObjectTagInfoEXT; + struct DebugReportCallbackCreateInfoEXT; + struct DebugUtilsLabelEXT; + struct DebugUtilsMessengerCallbackDataEXT; + struct DebugUtilsMessengerCreateInfoEXT; + struct DebugUtilsObjectNameInfoEXT; + struct DebugUtilsObjectTagInfoEXT; + struct DescriptorPoolCreateInfo; + struct DescriptorSetAllocateInfo; + struct DescriptorSetLayoutCreateInfo; + struct DescriptorSetLayoutSupport; + using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport; + struct DescriptorUpdateTemplateCreateInfo; + using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo; + struct DeviceCreateInfo; + struct DeviceEventInfoEXT; + struct DeviceGeneratedCommandsFeaturesNVX; + struct DeviceGeneratedCommandsLimitsNVX; + struct DeviceGroupPresentCapabilitiesKHR; + struct DeviceQueueInfo2; + struct DisplayEventInfoEXT; + struct DisplayModeCreateInfoKHR; + struct DisplayModeProperties2KHR; + struct DisplayModePropertiesKHR; + struct DisplayPlaneCapabilities2KHR; + struct DisplayPlaneCapabilitiesKHR; + struct DisplayPlaneInfo2KHR; + struct DisplayPlaneProperties2KHR; + struct DisplayPlanePropertiesKHR; + struct DisplayPowerInfoEXT; + struct DisplayProperties2KHR; + struct DisplayPropertiesKHR; + struct DisplaySurfaceCreateInfoKHR; + struct EventCreateInfo; + struct ExtensionProperties; + struct Extent2D; + struct ExternalBufferProperties; + using ExternalBufferPropertiesKHR = ExternalBufferProperties; + struct ExternalFenceProperties; + using ExternalFencePropertiesKHR = ExternalFenceProperties; + struct ExternalImageFormatPropertiesNV; + struct ExternalSemaphoreProperties; + using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties; + struct FenceCreateInfo; + struct FenceGetFdInfoKHR; +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct FenceGetWin32HandleInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + struct FormatProperties; + struct FormatProperties2; + using FormatProperties2KHR = FormatProperties2; + struct FramebufferCreateInfo; + struct GraphicsPipelineCreateInfo; + struct HdrMetadataEXT; +#ifdef VK_USE_PLATFORM_IOS_MVK + struct IOSSurfaceCreateInfoMVK; +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + struct ImageBlit; + struct ImageCopy; + struct ImageCreateInfo; + struct ImageDrmFormatModifierPropertiesEXT; + struct ImageFormatProperties; + struct ImageFormatProperties2; + using ImageFormatProperties2KHR = ImageFormatProperties2; + struct ImageMemoryBarrier; + struct ImageMemoryRequirementsInfo2; + using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2; +#ifdef VK_USE_PLATFORM_FUCHSIA + struct ImagePipeSurfaceCreateInfoFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + struct ImageResolve; + struct ImageSparseMemoryRequirementsInfo2; + using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2; + struct ImageSubresource; + struct ImageSubresourceRange; + struct ImageViewCreateInfo; + struct ImportFenceFdInfoKHR; +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ImportFenceWin32HandleInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + struct ImportSemaphoreFdInfoKHR; +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ImportSemaphoreWin32HandleInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + struct IndirectCommandsLayoutCreateInfoNVX; + struct InstanceCreateInfo; + struct LayerProperties; +#ifdef VK_USE_PLATFORM_MACOS_MVK + struct MacOSSurfaceCreateInfoMVK; +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + struct MappedMemoryRange; + struct MemoryAllocateInfo; + struct MemoryBarrier; + struct MemoryFdPropertiesKHR; +#ifdef VK_USE_PLATFORM_ANDROID_KHR + struct MemoryGetAndroidHardwareBufferInfoANDROID; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + struct MemoryGetFdInfoKHR; +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct MemoryGetWin32HandleInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + struct MemoryHostPointerPropertiesEXT; + struct MemoryRequirements; + struct MemoryRequirements2; + using MemoryRequirements2KHR = MemoryRequirements2; +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct MemoryWin32HandlePropertiesKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + struct MultisamplePropertiesEXT; + struct ObjectTableCreateInfoNVX; + struct ObjectTableEntryNVX; + struct PastPresentationTimingGOOGLE; + struct PhysicalDeviceExternalBufferInfo; + using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo; + struct PhysicalDeviceExternalFenceInfo; + using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo; + struct PhysicalDeviceExternalSemaphoreInfo; + using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo; + struct PhysicalDeviceFeatures; + struct PhysicalDeviceFeatures2; + using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2; + struct PhysicalDeviceGroupProperties; + using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties; + struct PhysicalDeviceImageFormatInfo2; + using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2; + struct PhysicalDeviceMemoryProperties; + struct PhysicalDeviceMemoryProperties2; + using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2; + struct PhysicalDeviceProperties; + struct PhysicalDeviceProperties2; + using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2; + struct PhysicalDeviceSparseImageFormatInfo2; + using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2; + struct PhysicalDeviceSurfaceInfo2KHR; + struct PipelineCacheCreateInfo; + struct PipelineLayoutCreateInfo; + struct PresentInfoKHR; + struct QueryPoolCreateInfo; + struct QueueFamilyProperties; + struct QueueFamilyProperties2; + using QueueFamilyProperties2KHR = QueueFamilyProperties2; + struct RayTracingPipelineCreateInfoNV; + struct Rect2D; + struct RefreshCycleDurationGOOGLE; + struct RenderPassBeginInfo; + struct RenderPassCreateInfo; + struct RenderPassCreateInfo2KHR; + struct SampleLocationsInfoEXT; + struct SamplerCreateInfo; + struct SamplerYcbcrConversionCreateInfo; + using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo; + struct SemaphoreCreateInfo; + struct SemaphoreGetFdInfoKHR; +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct SemaphoreGetWin32HandleInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + struct ShaderModuleCreateInfo; + struct ShadingRatePaletteNV; + struct SparseImageFormatProperties; + struct SparseImageFormatProperties2; + using SparseImageFormatProperties2KHR = SparseImageFormatProperties2; + struct SparseImageMemoryRequirements; + struct SparseImageMemoryRequirements2; + using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2; + struct SubmitInfo; + struct SubpassBeginInfoKHR; + struct SubpassEndInfoKHR; + struct SubresourceLayout; + struct SurfaceCapabilities2EXT; + struct SurfaceCapabilities2KHR; + struct SurfaceCapabilitiesKHR; + struct SurfaceFormat2KHR; + struct SurfaceFormatKHR; + struct SwapchainCreateInfoKHR; + struct ValidationCacheCreateInfoEXT; +#ifdef VK_USE_PLATFORM_VI_NN + struct ViSurfaceCreateInfoNN; +#endif /*VK_USE_PLATFORM_VI_NN*/ + struct Viewport; + struct ViewportWScalingNV; +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + struct WaylandSurfaceCreateInfoKHR; +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct Win32SurfaceCreateInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + struct WriteDescriptorSet; +#ifdef VK_USE_PLATFORM_XCB_KHR + struct XcbSurfaceCreateInfoKHR; +#endif /*VK_USE_PLATFORM_XCB_KHR*/ +#ifdef VK_USE_PLATFORM_XLIB_KHR + struct XlibSurfaceCreateInfoKHR; +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + + 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 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!" ); + + 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 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 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 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 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 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 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 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 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 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 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 AccelerationStructureNV + { + public: + VULKAN_HPP_CONSTEXPR AccelerationStructureNV() + : m_accelerationStructureNV(VK_NULL_HANDLE) + {} + + VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) + : m_accelerationStructureNV(VK_NULL_HANDLE) + {} + + VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) + : m_accelerationStructureNV( accelerationStructureNV ) + {} + +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) + AccelerationStructureNV & operator=(VkAccelerationStructureNV accelerationStructureNV) + { + m_accelerationStructureNV = accelerationStructureNV; + return *this; + } +#endif + + AccelerationStructureNV & operator=( std::nullptr_t ) + { + m_accelerationStructureNV = VK_NULL_HANDLE; + return *this; + } + + bool operator==( AccelerationStructureNV const & rhs ) const + { + return m_accelerationStructureNV == rhs.m_accelerationStructureNV; + } + + bool operator!=(AccelerationStructureNV const & rhs ) const + { + return m_accelerationStructureNV != rhs.m_accelerationStructureNV; + } + + bool operator<(AccelerationStructureNV const & rhs ) const + { + return m_accelerationStructureNV < rhs.m_accelerationStructureNV; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const + { + return m_accelerationStructureNV; + } + + explicit operator bool() const + { + return m_accelerationStructureNV != VK_NULL_HANDLE; + } + + bool operator!() const + { + return m_accelerationStructureNV == VK_NULL_HANDLE; + } + + private: + VkAccelerationStructureNV m_accelerationStructureNV; + }; + static_assert( sizeof( AccelerationStructureNV ) == sizeof( VkAccelerationStructureNV ), "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 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 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*/ + + template + void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, 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 beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d = Dispatch() ) const; + + template + void beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d = Dispatch() ) const; + + 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 beginRenderPass2KHR( const RenderPassBeginInfo* pRenderPassBegin, const SubpassBeginInfoKHR* pSubpassBeginInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, const SubpassBeginInfoKHR & subpassBeginInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy counterBuffers, ArrayProxy counterBufferOffsets, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + 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 bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d = Dispatch() ) const; + + template + void bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d = Dispatch() ) const; + + template + void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, const DeviceSize* pSizes, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, ArrayProxy buffers, ArrayProxy offsets, ArrayProxy sizes, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + 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 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 buildAccelerationStructureNV( const AccelerationStructureInfoNV* pInfo, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, 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 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 copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, 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 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 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 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 copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const; + + 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 dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, 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 dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d = Dispatch() ) const; + + 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 drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, 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 drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, 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 drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d = Dispatch() ) const; + + template + void drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, 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 drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const; + + template + void drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const; + + template + void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const &d = Dispatch() ) const; + + template + void endConditionalRenderingEXT(Dispatch const &d = Dispatch() ) const; + + template + void endDebugUtilsLabelEXT(Dispatch const &d = Dispatch() ) const; + + template + void endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const; + + template + void endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d = Dispatch() ) const; + + template + void endRenderPass(Dispatch const &d = Dispatch() ) const; + + template + void endRenderPass2KHR( const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void endRenderPass2KHR( const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void endTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy counterBuffers, ArrayProxy counterBufferOffsets, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + 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 fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, 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 nextSubpass( SubpassContents contents, Dispatch const &d = Dispatch() ) const; + + template + void nextSubpass2KHR( const SubpassBeginInfoKHR* pSubpassBeginInfo, const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void nextSubpass2KHR( const SubpassBeginInfoKHR & subpassBeginInfo, const SubpassEndInfoKHR & subpassEndInfo, 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 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 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 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 pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d = Dispatch() ) const; + + 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 resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d = Dispatch() ) const; + + template + void resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d = Dispatch() ) const; + + 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 setBlendConstants( const float blendConstants[4], Dispatch const &d = Dispatch() ) const; + + template + void setCheckpointNV( const void* pCheckpointMarker, Dispatch const &d = Dispatch() ) const; + + template + void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy customSampleOrders, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d = Dispatch() ) const; + + template + void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const &d = Dispatch() ) const; + + template + void setDeviceMask( uint32_t deviceMask, Dispatch const &d = Dispatch() ) const; + + template + void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d = Dispatch() ) const; + + 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 setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d = Dispatch() ) const; + + template + void setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const Rect2D* pExclusiveScissors, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy exclusiveScissors, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void setLineWidth( float lineWidth, Dispatch const &d = Dispatch() ) const; + + 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 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 setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d = Dispatch() ) const; + + template + void setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d = Dispatch() ) const; + + template + void setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, 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 setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy shadingRatePalettes, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + 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 traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d = Dispatch() ) const; + + 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 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 writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const AccelerationStructureNV* pAccelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void writeAccelerationStructuresPropertiesNV( ArrayProxy accelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, 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 writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const; + +#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*/ + + 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!" ); + + 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 + void getCheckpointDataNV( uint32_t* pCheckpointDataCount, CheckpointDataNV* pCheckpointData, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template, typename Dispatch = DispatchLoaderStatic> + std::vector getCheckpointDataNV(Dispatch const &d = Dispatch() ) const; + template, typename Dispatch = DispatchLoaderStatic> + std::vector getCheckpointDataNV(Allocator const& vectorAllocator, Dispatch const &d ) 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 + 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 + 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 + 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 + 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*/ + + 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!" ); + +#ifndef VULKAN_HPP_NO_SMART_HANDLE + class Device; + template class UniqueHandleTraits { public: using deleter = ObjectDestroy; }; + using UniqueAccelerationStructureNV = UniqueHandle; + 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 + 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 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 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType,Allocator>>::type allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType,Allocator>>::type allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType,Allocator>>::type allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType,Allocator>>::type allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#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 + typename 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 + Result bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type bindAccelerationStructureMemoryNV( ArrayProxy bindInfos, 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 + 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*/ + +#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 + 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*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + Result compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const; +#else + template + ResultValueType::type compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result createAccelerationStructureNV( const AccelerationStructureCreateInfoNV* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNV* pAccelerationStructure, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + typename ResultValueType>::type createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#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 + typename 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 + 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 + typename 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 + 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 + typename 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 + 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> + typename ResultValueType>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const; + template + 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,Allocator>>::type createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType,Allocator>>::type createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const; + template + typename 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 + 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 + typename 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 + 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 + typename 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 + 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 + typename 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 + typename 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 + 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 + typename 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 + 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 + typename 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 + 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 + typename 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 + 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> + typename ResultValueType>::type createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const; + template + 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,Allocator>>::type createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType,Allocator>>::type createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const; + template + typename 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 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 + typename 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 + 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 + typename 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 + 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 + typename 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 + 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 + typename 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 + 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 + typename 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 + 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 + typename 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 + 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 + typename 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 + Result createRayTracingPipelinesNV( PipelineCache pipelineCache, uint32_t createInfoCount, const RayTracingPipelineCreateInfoNV* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const; + template + ResultValueType::type createRayTracingPipelineNV( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType,Allocator>>::type createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType,Allocator>>::type createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const; + template + typename ResultValueType>::type createRayTracingPipelineNVUnique( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#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 + typename 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 + Result createRenderPass2KHR( const RenderPassCreateInfo2KHR* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createRenderPass2KHR( const RenderPassCreateInfo2KHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + typename ResultValueType>::type createRenderPass2KHRUnique( const RenderPassCreateInfo2KHR & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#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 + typename 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 + 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 + typename 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 + typename 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 + 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 + typename 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 + 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 + typename 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 + 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> + typename ResultValueType>::type createSharedSwapchainsKHR( ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const; + template + 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,Allocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy createInfos, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType,Allocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const; + template + typename 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 + typename 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 + 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 + typename 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 + 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*/ + + template + void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( AccelerationStructureNV accelerationStructure, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#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 + 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 + 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*/ + + 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*/ + + 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 + 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 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 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 + 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 + 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 + 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 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 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 + 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 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 + 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 + 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 + 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*/ + +#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 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 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 + 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 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 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 getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, ArrayProxy data, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + void getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d = Dispatch() ) const; + template + StructureChain getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + 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_KHR*/ + + template + DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfoEXT* pInfo, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfoEXT & info, 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*/ + + 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 + Result getCalibratedTimestampsEXT( uint32_t timestampCount, const CalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getCalibratedTimestampsEXT( ArrayProxy timestampInfos, ArrayProxy timestamps, 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 + 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 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 + 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 + 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 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*/ + + 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 getEventStatus( Event event, Dispatch const &d = Dispatch() ) const; + + 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 getFenceStatus( Fence fence, Dispatch const &d = Dispatch() ) const; + +#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*/ + + template + Result getImageDrmFormatModifierPropertiesEXT( Image image, ImageDrmFormatModifierPropertiesEXT* pProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getImageDrmFormatModifierPropertiesEXT( Image image, 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*/ + + 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 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; + template, typename Dispatch = DispatchLoaderStatic> + std::vector getImageSparseMemoryRequirements( Image image, Allocator const& vectorAllocator, Dispatch const &d ) 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; + template, typename Dispatch = DispatchLoaderStatic> + std::vector getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) 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; + template, typename Dispatch = DispatchLoaderStatic> + std::vector getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) 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*/ + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + 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_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*/ + + 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_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 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_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 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getPipelineCacheData( PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) 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 getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy data, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + 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 + 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 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*/ + +#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*/ + + 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Allocator const& vectorAllocator, Dispatch const &d ) 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 + 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getSwapchainImagesKHR( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const; + + 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache, Allocator const& vectorAllocator, Dispatch const &d ) 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*/ + +#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 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 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 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 + 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 + 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 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 + 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 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*/ + +#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*/ + +#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*/ + +#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 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 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*/ + +#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*/ + + 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 + 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; + + template + void unmapMemory( DeviceMemory memory, Dispatch const &d = Dispatch() ) const; + + 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 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 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 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*/ + + 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!" ); + + 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!" ); + +#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; + } + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + 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_EXT*/ + + 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 + typename 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 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 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type enumerateDeviceExtensionProperties( Optional layerName, Allocator const& vectorAllocator, Dispatch const &d ) const; +#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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type enumerateDeviceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d ) 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getDisplayModeProperties2KHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getDisplayModePropertiesKHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) 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*/ + + 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*/ + + 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Allocator const& vectorAllocator, Dispatch const &d ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getCalibrateableTimeDomainsEXT( uint32_t* pTimeDomainCount, TimeDomainEXT* pTimeDomains, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getCalibrateableTimeDomainsEXT(Dispatch const &d = Dispatch() ) const; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getCalibrateableTimeDomainsEXT(Allocator const& vectorAllocator, Dispatch const &d ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getCooperativeMatrixPropertiesNV( uint32_t* pPropertyCount, CooperativeMatrixPropertiesNV* pProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getCooperativeMatrixPropertiesNV(Dispatch const &d = Dispatch() ) const; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getCooperativeMatrixPropertiesNV(Allocator const& vectorAllocator, Dispatch const &d ) 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getDisplayPlaneProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getDisplayPlanePropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getDisplayProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getDisplayPropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) 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 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*/ + + 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 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 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 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 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 + 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; + template + StructureChain 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; + template + StructureChain getFormatProperties2KHR( Format format, 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 + 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 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 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 getMemoryProperties2( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + PhysicalDeviceMemoryProperties2 getMemoryProperties2(Dispatch const &d = Dispatch() ) const; + template + StructureChain 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; + template + StructureChain getMemoryProperties2KHR(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 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getPresentRectanglesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + 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 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 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; + template, typename Dispatch = DispatchLoaderStatic> + std::vector getQueueFamilyProperties(Allocator const& vectorAllocator, Dispatch const &d ) 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; + template, typename Dispatch = DispatchLoaderStatic> + std::vector getQueueFamilyProperties2(Allocator const& vectorAllocator, Dispatch const &d ) const; + template, typename Dispatch = DispatchLoaderStatic> + std::vector getQueueFamilyProperties2(Dispatch const &d = Dispatch() ) const; + template, typename Dispatch = DispatchLoaderStatic> + std::vector getQueueFamilyProperties2(Allocator const& vectorAllocator, Dispatch const &d ) 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; + template, typename Dispatch = DispatchLoaderStatic> + std::vector getQueueFamilyProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const; + template, typename Dispatch = DispatchLoaderStatic> + std::vector getQueueFamilyProperties2KHR(Dispatch const &d = Dispatch() ) const; + template, typename Dispatch = DispatchLoaderStatic> + std::vector getQueueFamilyProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) 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; + template, typename Dispatch = DispatchLoaderStatic> + std::vector getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Allocator const& vectorAllocator, Dispatch const &d ) 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; + template, typename Dispatch = DispatchLoaderStatic> + std::vector getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) 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; + template, typename Dispatch = DispatchLoaderStatic> + std::vector getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + 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 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 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 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Allocator const& vectorAllocator, Dispatch const &d ) 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getSurfaceFormatsKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type getSurfacePresentModesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + 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*/ + +#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_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*/ + +#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_XLIB_XRANDR_EXT + 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_EXT*/ + +#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*/ + + 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!" ); + +#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; + } + +#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 + typename 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 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 + typename 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 + 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 + typename 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 + 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 + typename 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_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 + typename 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_FUCHSIA + template + Result createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + typename ResultValueType>::type createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & 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_FUCHSIA*/ + +#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 + typename 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*/ + +#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 + typename 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 + typename 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 + typename 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_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 + typename 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*/ + +#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 + typename 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*/ + + 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 + 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 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 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 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*/ + + 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type enumeratePhysicalDeviceGroups(Allocator const& vectorAllocator, Dispatch const &d ) 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type enumeratePhysicalDeviceGroupsKHR(Allocator const& vectorAllocator, Dispatch const &d ) 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; + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type enumeratePhysicalDevices(Allocator const& vectorAllocator, Dispatch const &d ) 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*/ + + 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!" ); + +#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 + typename 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 + 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() ); + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type enumerateInstanceExtensionProperties( Optional layerName, Allocator const& vectorAllocator, Dispatch const &d ); +#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() ); + template, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType>::type enumerateInstanceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d ); +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + 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*/ + + struct GeometryTrianglesNV + { + GeometryTrianglesNV( Buffer vertexData_ = Buffer(), + DeviceSize vertexOffset_ = 0, + uint32_t vertexCount_ = 0, + DeviceSize vertexStride_ = 0, + Format vertexFormat_ = Format::eUndefined, + Buffer indexData_ = Buffer(), + DeviceSize indexOffset_ = 0, + uint32_t indexCount_ = 0, + IndexType indexType_ = IndexType::eUint16, + Buffer transformData_ = Buffer(), + DeviceSize transformOffset_ = 0 ) + : vertexData( vertexData_ ) + , vertexOffset( vertexOffset_ ) + , vertexCount( vertexCount_ ) + , vertexStride( vertexStride_ ) + , vertexFormat( vertexFormat_ ) + , indexData( indexData_ ) + , indexOffset( indexOffset_ ) + , indexCount( indexCount_ ) + , indexType( indexType_ ) + , transformData( transformData_ ) + , transformOffset( transformOffset_ ) + {} + + GeometryTrianglesNV( VkGeometryTrianglesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( GeometryTrianglesNV ) ); + } + + GeometryTrianglesNV& operator=( VkGeometryTrianglesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( GeometryTrianglesNV ) ); + return *this; + } + + GeometryTrianglesNV & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + GeometryTrianglesNV & setVertexData( Buffer vertexData_ ) + { + vertexData = vertexData_; + return *this; + } + + GeometryTrianglesNV & setVertexOffset( DeviceSize vertexOffset_ ) + { + vertexOffset = vertexOffset_; + return *this; + } + + GeometryTrianglesNV & setVertexCount( uint32_t vertexCount_ ) + { + vertexCount = vertexCount_; + return *this; + } + + GeometryTrianglesNV & setVertexStride( DeviceSize vertexStride_ ) + { + vertexStride = vertexStride_; + return *this; + } + + GeometryTrianglesNV & setVertexFormat( Format vertexFormat_ ) + { + vertexFormat = vertexFormat_; + return *this; + } + + GeometryTrianglesNV & setIndexData( Buffer indexData_ ) + { + indexData = indexData_; + return *this; + } + + GeometryTrianglesNV & setIndexOffset( DeviceSize indexOffset_ ) + { + indexOffset = indexOffset_; + return *this; + } + + GeometryTrianglesNV & setIndexCount( uint32_t indexCount_ ) + { + indexCount = indexCount_; + return *this; + } + + GeometryTrianglesNV & setIndexType( IndexType indexType_ ) + { + indexType = indexType_; + return *this; + } + + GeometryTrianglesNV & setTransformData( Buffer transformData_ ) + { + transformData = transformData_; + return *this; + } + + GeometryTrianglesNV & setTransformOffset( DeviceSize transformOffset_ ) + { + transformOffset = transformOffset_; + return *this; + } + + operator VkGeometryTrianglesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkGeometryTrianglesNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( GeometryTrianglesNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( vertexData == rhs.vertexData ) + && ( vertexOffset == rhs.vertexOffset ) + && ( vertexCount == rhs.vertexCount ) + && ( vertexStride == rhs.vertexStride ) + && ( vertexFormat == rhs.vertexFormat ) + && ( indexData == rhs.indexData ) + && ( indexOffset == rhs.indexOffset ) + && ( indexCount == rhs.indexCount ) + && ( indexType == rhs.indexType ) + && ( transformData == rhs.transformData ) + && ( transformOffset == rhs.transformOffset ); + } + + bool operator!=( GeometryTrianglesNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eGeometryTrianglesNV; + + public: + const void* pNext = nullptr; + Buffer vertexData; + DeviceSize vertexOffset; + uint32_t vertexCount; + DeviceSize vertexStride; + Format vertexFormat; + Buffer indexData; + DeviceSize indexOffset; + uint32_t indexCount; + IndexType indexType; + Buffer transformData; + DeviceSize transformOffset; + }; + static_assert( sizeof( GeometryTrianglesNV ) == sizeof( VkGeometryTrianglesNV ), "struct and wrapper have different size!" ); + + struct GeometryAABBNV + { + GeometryAABBNV( Buffer aabbData_ = Buffer(), + uint32_t numAABBs_ = 0, + uint32_t stride_ = 0, + DeviceSize offset_ = 0 ) + : aabbData( aabbData_ ) + , numAABBs( numAABBs_ ) + , stride( stride_ ) + , offset( offset_ ) + {} + + GeometryAABBNV( VkGeometryAABBNV const & rhs ) + { + memcpy( this, &rhs, sizeof( GeometryAABBNV ) ); + } + + GeometryAABBNV& operator=( VkGeometryAABBNV const & rhs ) + { + memcpy( this, &rhs, sizeof( GeometryAABBNV ) ); + return *this; + } + + GeometryAABBNV & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + GeometryAABBNV & setAabbData( Buffer aabbData_ ) + { + aabbData = aabbData_; + return *this; + } + + GeometryAABBNV & setNumAABBs( uint32_t numAABBs_ ) + { + numAABBs = numAABBs_; + return *this; + } + + GeometryAABBNV & setStride( uint32_t stride_ ) + { + stride = stride_; + return *this; + } + + GeometryAABBNV & setOffset( DeviceSize offset_ ) + { + offset = offset_; + return *this; + } + + operator VkGeometryAABBNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkGeometryAABBNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( GeometryAABBNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( aabbData == rhs.aabbData ) + && ( numAABBs == rhs.numAABBs ) + && ( stride == rhs.stride ) + && ( offset == rhs.offset ); + } + + bool operator!=( GeometryAABBNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eGeometryAabbNV; + + public: + const void* pNext = nullptr; + Buffer aabbData; + uint32_t numAABBs; + uint32_t stride; + DeviceSize offset; + }; + static_assert( sizeof( GeometryAABBNV ) == sizeof( VkGeometryAABBNV ), "struct and wrapper have different size!" ); + + struct GeometryDataNV + { + GeometryDataNV( GeometryTrianglesNV triangles_ = GeometryTrianglesNV(), + GeometryAABBNV aabbs_ = GeometryAABBNV() ) + : triangles( triangles_ ) + , aabbs( aabbs_ ) + {} + + GeometryDataNV( VkGeometryDataNV const & rhs ) + { + memcpy( this, &rhs, sizeof( GeometryDataNV ) ); + } + + GeometryDataNV& operator=( VkGeometryDataNV const & rhs ) + { + memcpy( this, &rhs, sizeof( GeometryDataNV ) ); + return *this; + } + + GeometryDataNV & setTriangles( GeometryTrianglesNV triangles_ ) + { + triangles = triangles_; + return *this; + } + + GeometryDataNV & setAabbs( GeometryAABBNV aabbs_ ) + { + aabbs = aabbs_; + return *this; + } + + operator VkGeometryDataNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkGeometryDataNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( GeometryDataNV const& rhs ) const + { + return ( triangles == rhs.triangles ) + && ( aabbs == rhs.aabbs ); + } + + bool operator!=( GeometryDataNV const& rhs ) const + { + return !operator==( rhs ); + } + + GeometryTrianglesNV triangles; + GeometryAABBNV aabbs; + }; + static_assert( sizeof( GeometryDataNV ) == sizeof( VkGeometryDataNV ), "struct and wrapper have different size!" ); + + struct GeometryNV + { + GeometryNV( GeometryTypeNV geometryType_ = GeometryTypeNV::eTriangles, + GeometryDataNV geometry_ = GeometryDataNV(), + GeometryFlagsNV flags_ = GeometryFlagsNV() ) + : geometryType( geometryType_ ) + , geometry( geometry_ ) + , flags( flags_ ) + {} + + GeometryNV( VkGeometryNV const & rhs ) + { + memcpy( this, &rhs, sizeof( GeometryNV ) ); + } + + GeometryNV& operator=( VkGeometryNV const & rhs ) + { + memcpy( this, &rhs, sizeof( GeometryNV ) ); + return *this; + } + + GeometryNV & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + GeometryNV & setGeometryType( GeometryTypeNV geometryType_ ) + { + geometryType = geometryType_; + return *this; + } + + GeometryNV & setGeometry( GeometryDataNV geometry_ ) + { + geometry = geometry_; + return *this; + } + + GeometryNV & setFlags( GeometryFlagsNV flags_ ) + { + flags = flags_; + return *this; + } + + operator VkGeometryNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkGeometryNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( GeometryNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( geometryType == rhs.geometryType ) + && ( geometry == rhs.geometry ) + && ( flags == rhs.flags ); + } + + bool operator!=( GeometryNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eGeometryNV; + + public: + const void* pNext = nullptr; + GeometryTypeNV geometryType; + GeometryDataNV geometry; + GeometryFlagsNV flags; + }; + static_assert( sizeof( GeometryNV ) == sizeof( VkGeometryNV ), "struct and wrapper have different size!" ); + + struct AccelerationStructureInfoNV + { + AccelerationStructureInfoNV( AccelerationStructureTypeNV type_ = AccelerationStructureTypeNV::eTopLevel, + BuildAccelerationStructureFlagsNV flags_ = BuildAccelerationStructureFlagsNV(), + uint32_t instanceCount_ = 0, + uint32_t geometryCount_ = 0, + const GeometryNV* pGeometries_ = nullptr ) + : type( type_ ) + , flags( flags_ ) + , instanceCount( instanceCount_ ) + , geometryCount( geometryCount_ ) + , pGeometries( pGeometries_ ) + {} + + AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( AccelerationStructureInfoNV ) ); + } + + AccelerationStructureInfoNV& operator=( VkAccelerationStructureInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( AccelerationStructureInfoNV ) ); + return *this; + } + + AccelerationStructureInfoNV & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + AccelerationStructureInfoNV & setType( AccelerationStructureTypeNV type_ ) + { + type = type_; + return *this; + } + + AccelerationStructureInfoNV & setFlags( BuildAccelerationStructureFlagsNV flags_ ) + { + flags = flags_; + return *this; + } + + AccelerationStructureInfoNV & setInstanceCount( uint32_t instanceCount_ ) + { + instanceCount = instanceCount_; + return *this; + } + + AccelerationStructureInfoNV & setGeometryCount( uint32_t geometryCount_ ) + { + geometryCount = geometryCount_; + return *this; + } + + AccelerationStructureInfoNV & setPGeometries( const GeometryNV* pGeometries_ ) + { + pGeometries = pGeometries_; + return *this; + } + + operator VkAccelerationStructureInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureInfoNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( AccelerationStructureInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( type == rhs.type ) + && ( flags == rhs.flags ) + && ( instanceCount == rhs.instanceCount ) + && ( geometryCount == rhs.geometryCount ) + && ( pGeometries == rhs.pGeometries ); + } + + bool operator!=( AccelerationStructureInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eAccelerationStructureInfoNV; + + public: + const void* pNext = nullptr; + AccelerationStructureTypeNV type; + BuildAccelerationStructureFlagsNV flags; + uint32_t instanceCount; + uint32_t geometryCount; + const GeometryNV* pGeometries; + }; + static_assert( sizeof( AccelerationStructureInfoNV ) == sizeof( VkAccelerationStructureInfoNV ), "struct and wrapper have different size!" ); + + struct AccelerationStructureCreateInfoNV + { + AccelerationStructureCreateInfoNV( DeviceSize compactedSize_ = 0, + AccelerationStructureInfoNV info_ = AccelerationStructureInfoNV() ) + : compactedSize( compactedSize_ ) + , info( info_ ) + {} + + AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( AccelerationStructureCreateInfoNV ) ); + } + + AccelerationStructureCreateInfoNV& operator=( VkAccelerationStructureCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( AccelerationStructureCreateInfoNV ) ); + return *this; + } + + AccelerationStructureCreateInfoNV & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + AccelerationStructureCreateInfoNV & setCompactedSize( DeviceSize compactedSize_ ) + { + compactedSize = compactedSize_; + return *this; + } + + AccelerationStructureCreateInfoNV & setInfo( AccelerationStructureInfoNV info_ ) + { + info = info_; + return *this; + } + + operator VkAccelerationStructureCreateInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureCreateInfoNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( AccelerationStructureCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( compactedSize == rhs.compactedSize ) + && ( info == rhs.info ); + } + + bool operator!=( AccelerationStructureCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eAccelerationStructureCreateInfoNV; + + public: + const void* pNext = nullptr; + DeviceSize compactedSize; + AccelerationStructureInfoNV info; + }; + static_assert( sizeof( AccelerationStructureCreateInfoNV ) == sizeof( VkAccelerationStructureCreateInfoNV ), "struct and wrapper have different size!" ); + + struct AccelerationStructureMemoryRequirementsInfoNV + { + AccelerationStructureMemoryRequirementsInfoNV( AccelerationStructureMemoryRequirementsTypeNV type_ = AccelerationStructureMemoryRequirementsTypeNV::eObject, + AccelerationStructureNV accelerationStructure_ = AccelerationStructureNV() ) + : type( type_ ) + , accelerationStructure( accelerationStructure_ ) + {} + + AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( AccelerationStructureMemoryRequirementsInfoNV ) ); + } + + AccelerationStructureMemoryRequirementsInfoNV& operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( AccelerationStructureMemoryRequirementsInfoNV ) ); + return *this; + } + + AccelerationStructureMemoryRequirementsInfoNV & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + AccelerationStructureMemoryRequirementsInfoNV & setType( AccelerationStructureMemoryRequirementsTypeNV type_ ) + { + type = type_; + return *this; + } + + AccelerationStructureMemoryRequirementsInfoNV & setAccelerationStructure( AccelerationStructureNV accelerationStructure_ ) + { + accelerationStructure = accelerationStructure_; + return *this; + } + + operator VkAccelerationStructureMemoryRequirementsInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureMemoryRequirementsInfoNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( AccelerationStructureMemoryRequirementsInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( type == rhs.type ) + && ( accelerationStructure == rhs.accelerationStructure ); + } + + bool operator!=( AccelerationStructureMemoryRequirementsInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV; + + public: + const void* pNext = nullptr; + AccelerationStructureMemoryRequirementsTypeNV type; + AccelerationStructureNV accelerationStructure; + }; + static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoNV ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoNV ), "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 VkAcquireNextImageInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkAcquireNextImageInfoKHR &() + { + 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 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 VkAllocationCallbacks const&() const + { + return *reinterpret_cast( this ); + } + + operator VkAllocationCallbacks &() + { + 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 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 VkComponentMapping const&() const + { + return *reinterpret_cast( this ); + } + + operator VkComponentMapping &() + { + 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!" ); + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + struct AndroidHardwareBufferFormatPropertiesANDROID + { + operator VkAndroidHardwareBufferFormatPropertiesANDROID const&() const + { + return *reinterpret_cast( this ); + } + + operator VkAndroidHardwareBufferFormatPropertiesANDROID &() + { + 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_KHR*/ + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + struct AndroidHardwareBufferPropertiesANDROID + { + operator VkAndroidHardwareBufferPropertiesANDROID const&() const + { + return *reinterpret_cast( this ); + } + + operator VkAndroidHardwareBufferPropertiesANDROID &() + { + 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_KHR*/ + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + struct AndroidHardwareBufferUsageANDROID + { + operator VkAndroidHardwareBufferUsageANDROID const&() const + { + return *reinterpret_cast( this ); + } + + operator VkAndroidHardwareBufferUsageANDROID &() + { + 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_KHR*/ + +#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 VkAndroidSurfaceCreateInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkAndroidSurfaceCreateInfoKHR &() + { + 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*/ + + 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 VkApplicationInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkApplicationInfo &() + { + 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 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 VkAttachmentDescription const&() const + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentDescription &() + { + 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!" ); + + struct AttachmentDescription2KHR + { + AttachmentDescription2KHR( 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_ ) + {} + + AttachmentDescription2KHR( VkAttachmentDescription2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( AttachmentDescription2KHR ) ); + } + + AttachmentDescription2KHR& operator=( VkAttachmentDescription2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( AttachmentDescription2KHR ) ); + return *this; + } + + AttachmentDescription2KHR & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + AttachmentDescription2KHR & setFlags( AttachmentDescriptionFlags flags_ ) + { + flags = flags_; + return *this; + } + + AttachmentDescription2KHR & setFormat( Format format_ ) + { + format = format_; + return *this; + } + + AttachmentDescription2KHR & setSamples( SampleCountFlagBits samples_ ) + { + samples = samples_; + return *this; + } + + AttachmentDescription2KHR & setLoadOp( AttachmentLoadOp loadOp_ ) + { + loadOp = loadOp_; + return *this; + } + + AttachmentDescription2KHR & setStoreOp( AttachmentStoreOp storeOp_ ) + { + storeOp = storeOp_; + return *this; + } + + AttachmentDescription2KHR & setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ ) + { + stencilLoadOp = stencilLoadOp_; + return *this; + } + + AttachmentDescription2KHR & setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ ) + { + stencilStoreOp = stencilStoreOp_; + return *this; + } + + AttachmentDescription2KHR & setInitialLayout( ImageLayout initialLayout_ ) + { + initialLayout = initialLayout_; + return *this; + } + + AttachmentDescription2KHR & setFinalLayout( ImageLayout finalLayout_ ) + { + finalLayout = finalLayout_; + return *this; + } + + operator VkAttachmentDescription2KHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentDescription2KHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( AttachmentDescription2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( 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!=( AttachmentDescription2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eAttachmentDescription2KHR; + + public: + const void* pNext = nullptr; + AttachmentDescriptionFlags flags; + Format format; + SampleCountFlagBits samples; + AttachmentLoadOp loadOp; + AttachmentStoreOp storeOp; + AttachmentLoadOp stencilLoadOp; + AttachmentStoreOp stencilStoreOp; + ImageLayout initialLayout; + ImageLayout finalLayout; + }; + static_assert( sizeof( AttachmentDescription2KHR ) == sizeof( VkAttachmentDescription2KHR ), "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 VkAttachmentReference const&() const + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentReference &() + { + 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!" ); + + struct AttachmentReference2KHR + { + AttachmentReference2KHR( uint32_t attachment_ = 0, + ImageLayout layout_ = ImageLayout::eUndefined, + ImageAspectFlags aspectMask_ = ImageAspectFlags() ) + : attachment( attachment_ ) + , layout( layout_ ) + , aspectMask( aspectMask_ ) + {} + + AttachmentReference2KHR( VkAttachmentReference2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( AttachmentReference2KHR ) ); + } + + AttachmentReference2KHR& operator=( VkAttachmentReference2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( AttachmentReference2KHR ) ); + return *this; + } + + AttachmentReference2KHR & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + AttachmentReference2KHR & setAttachment( uint32_t attachment_ ) + { + attachment = attachment_; + return *this; + } + + AttachmentReference2KHR & setLayout( ImageLayout layout_ ) + { + layout = layout_; + return *this; + } + + AttachmentReference2KHR & setAspectMask( ImageAspectFlags aspectMask_ ) + { + aspectMask = aspectMask_; + return *this; + } + + operator VkAttachmentReference2KHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentReference2KHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( AttachmentReference2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( attachment == rhs.attachment ) + && ( layout == rhs.layout ) + && ( aspectMask == rhs.aspectMask ); + } + + bool operator!=( AttachmentReference2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eAttachmentReference2KHR; + + public: + const void* pNext = nullptr; + uint32_t attachment; + ImageLayout layout; + ImageAspectFlags aspectMask; + }; + static_assert( sizeof( AttachmentReference2KHR ) == sizeof( VkAttachmentReference2KHR ), "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 VkExtent2D const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExtent2D &() + { + 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 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 VkSampleLocationEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSampleLocationEXT &() + { + 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 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 VkSampleLocationsInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSampleLocationsInfoEXT &() + { + 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 VkAttachmentSampleLocationsEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentSampleLocationsEXT &() + { + 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 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 VkBaseInStructure const&() const + { + return *reinterpret_cast( this ); + } + + operator VkBaseInStructure &() + { + 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!" ); + + 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 VkBaseOutStructure const&() const + { + return *reinterpret_cast( this ); + } + + operator VkBaseOutStructure &() + { + 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 BindAccelerationStructureMemoryInfoNV + { + BindAccelerationStructureMemoryInfoNV( AccelerationStructureNV accelerationStructure_ = AccelerationStructureNV(), + DeviceMemory memory_ = DeviceMemory(), + DeviceSize memoryOffset_ = 0, + uint32_t deviceIndexCount_ = 0, + const uint32_t* pDeviceIndices_ = nullptr ) + : accelerationStructure( accelerationStructure_ ) + , memory( memory_ ) + , memoryOffset( memoryOffset_ ) + , deviceIndexCount( deviceIndexCount_ ) + , pDeviceIndices( pDeviceIndices_ ) + {} + + BindAccelerationStructureMemoryInfoNV( VkBindAccelerationStructureMemoryInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( BindAccelerationStructureMemoryInfoNV ) ); + } + + BindAccelerationStructureMemoryInfoNV& operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( BindAccelerationStructureMemoryInfoNV ) ); + return *this; + } + + BindAccelerationStructureMemoryInfoNV & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + BindAccelerationStructureMemoryInfoNV & setAccelerationStructure( AccelerationStructureNV accelerationStructure_ ) + { + accelerationStructure = accelerationStructure_; + return *this; + } + + BindAccelerationStructureMemoryInfoNV & setMemory( DeviceMemory memory_ ) + { + memory = memory_; + return *this; + } + + BindAccelerationStructureMemoryInfoNV & setMemoryOffset( DeviceSize memoryOffset_ ) + { + memoryOffset = memoryOffset_; + return *this; + } + + BindAccelerationStructureMemoryInfoNV & setDeviceIndexCount( uint32_t deviceIndexCount_ ) + { + deviceIndexCount = deviceIndexCount_; + return *this; + } + + BindAccelerationStructureMemoryInfoNV & setPDeviceIndices( const uint32_t* pDeviceIndices_ ) + { + pDeviceIndices = pDeviceIndices_; + return *this; + } + + operator VkBindAccelerationStructureMemoryInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkBindAccelerationStructureMemoryInfoNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( BindAccelerationStructureMemoryInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( accelerationStructure == rhs.accelerationStructure ) + && ( memory == rhs.memory ) + && ( memoryOffset == rhs.memoryOffset ) + && ( deviceIndexCount == rhs.deviceIndexCount ) + && ( pDeviceIndices == rhs.pDeviceIndices ); + } + + bool operator!=( BindAccelerationStructureMemoryInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoNV; + + public: + const void* pNext = nullptr; + AccelerationStructureNV accelerationStructure; + DeviceMemory memory; + DeviceSize memoryOffset; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; + }; + static_assert( sizeof( BindAccelerationStructureMemoryInfoNV ) == sizeof( VkBindAccelerationStructureMemoryInfoNV ), "struct and wrapper have different size!" ); + + 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 VkBindBufferMemoryDeviceGroupInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkBindBufferMemoryDeviceGroupInfo &() + { + 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!" ); + + 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 VkBindBufferMemoryInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkBindBufferMemoryInfo &() + { + 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!" ); + + 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 VkOffset2D const&() const + { + return *reinterpret_cast( this ); + } + + operator VkOffset2D &() + { + 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 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 VkRect2D const&() const + { + return *reinterpret_cast( this ); + } + + operator VkRect2D &() + { + 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 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 VkBindImageMemoryDeviceGroupInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkBindImageMemoryDeviceGroupInfo &() + { + 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!" ); + + 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 VkBindImageMemoryInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkBindImageMemoryInfo &() + { + 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!" ); + + 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 VkBindImageMemorySwapchainInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkBindImageMemorySwapchainInfoKHR &() + { + 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 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 VkBindImagePlaneMemoryInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkBindImagePlaneMemoryInfo &() + { + 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!" ); + + 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 VkSparseMemoryBind const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSparseMemoryBind &() + { + 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 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 VkSparseBufferMemoryBindInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSparseBufferMemoryBindInfo &() + { + 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 VkSparseImageOpaqueMemoryBindInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageOpaqueMemoryBindInfo &() + { + 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 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 VkImageSubresource const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageSubresource &() + { + 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 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 VkOffset3D const&() const + { + return *reinterpret_cast( this ); + } + + operator VkOffset3D &() + { + 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 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 VkExtent3D const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExtent3D &() + { + 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 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 VkSparseImageMemoryBind const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageMemoryBind &() + { + 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 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 VkSparseImageMemoryBindInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageMemoryBindInfo &() + { + 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 VkBindSparseInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkBindSparseInfo &() + { + 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!" ); + + 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 VkBufferCopy const&() const + { + return *reinterpret_cast( this ); + } + + operator VkBufferCopy &() + { + 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 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 VkBufferCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkBufferCreateInfo &() + { + 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!" ); + + struct BufferDeviceAddressCreateInfoEXT + { + BufferDeviceAddressCreateInfoEXT( DeviceSize deviceAddress_ = 0 ) + : deviceAddress( deviceAddress_ ) + {} + + BufferDeviceAddressCreateInfoEXT( VkBufferDeviceAddressCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( BufferDeviceAddressCreateInfoEXT ) ); + } + + BufferDeviceAddressCreateInfoEXT& operator=( VkBufferDeviceAddressCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( BufferDeviceAddressCreateInfoEXT ) ); + return *this; + } + + BufferDeviceAddressCreateInfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + BufferDeviceAddressCreateInfoEXT & setDeviceAddress( DeviceSize deviceAddress_ ) + { + deviceAddress = deviceAddress_; + return *this; + } + + operator VkBufferDeviceAddressCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkBufferDeviceAddressCreateInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( BufferDeviceAddressCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( deviceAddress == rhs.deviceAddress ); + } + + bool operator!=( BufferDeviceAddressCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eBufferDeviceAddressCreateInfoEXT; + + public: + const void* pNext = nullptr; + DeviceSize deviceAddress; + }; + static_assert( sizeof( BufferDeviceAddressCreateInfoEXT ) == sizeof( VkBufferDeviceAddressCreateInfoEXT ), "struct and wrapper have different size!" ); + + struct BufferDeviceAddressInfoEXT + { + BufferDeviceAddressInfoEXT( Buffer buffer_ = Buffer() ) + : buffer( buffer_ ) + {} + + BufferDeviceAddressInfoEXT( VkBufferDeviceAddressInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( BufferDeviceAddressInfoEXT ) ); + } + + BufferDeviceAddressInfoEXT& operator=( VkBufferDeviceAddressInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( BufferDeviceAddressInfoEXT ) ); + return *this; + } + + BufferDeviceAddressInfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + BufferDeviceAddressInfoEXT & setBuffer( Buffer buffer_ ) + { + buffer = buffer_; + return *this; + } + + operator VkBufferDeviceAddressInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkBufferDeviceAddressInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( BufferDeviceAddressInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( buffer == rhs.buffer ); + } + + bool operator!=( BufferDeviceAddressInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eBufferDeviceAddressInfoEXT; + + public: + const void* pNext = nullptr; + Buffer buffer; + }; + static_assert( sizeof( BufferDeviceAddressInfoEXT ) == sizeof( VkBufferDeviceAddressInfoEXT ), "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 VkImageSubresourceLayers const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageSubresourceLayers &() + { + 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 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 VkBufferImageCopy const&() const + { + return *reinterpret_cast( this ); + } + + operator VkBufferImageCopy &() + { + 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 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 VkBufferMemoryBarrier const&() const + { + return *reinterpret_cast( this ); + } + + operator VkBufferMemoryBarrier &() + { + 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!" ); + + 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 VkBufferMemoryRequirementsInfo2 const&() const + { + return *reinterpret_cast( this ); + } + + operator VkBufferMemoryRequirementsInfo2 &() + { + 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!" ); + + 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 VkBufferViewCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkBufferViewCreateInfo &() + { + 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 CalibratedTimestampInfoEXT + { + CalibratedTimestampInfoEXT( TimeDomainEXT timeDomain_ = TimeDomainEXT::eDevice ) + : timeDomain( timeDomain_ ) + {} + + CalibratedTimestampInfoEXT( VkCalibratedTimestampInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( CalibratedTimestampInfoEXT ) ); + } + + CalibratedTimestampInfoEXT& operator=( VkCalibratedTimestampInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( CalibratedTimestampInfoEXT ) ); + return *this; + } + + CalibratedTimestampInfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + CalibratedTimestampInfoEXT & setTimeDomain( TimeDomainEXT timeDomain_ ) + { + timeDomain = timeDomain_; + return *this; + } + + operator VkCalibratedTimestampInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkCalibratedTimestampInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( CalibratedTimestampInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( timeDomain == rhs.timeDomain ); + } + + bool operator!=( CalibratedTimestampInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eCalibratedTimestampInfoEXT; + + public: + const void* pNext = nullptr; + TimeDomainEXT timeDomain; + }; + static_assert( sizeof( CalibratedTimestampInfoEXT ) == sizeof( VkCalibratedTimestampInfoEXT ), "struct and wrapper have different size!" ); + + struct CheckpointDataNV + { + operator VkCheckpointDataNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkCheckpointDataNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( CheckpointDataNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( stage == rhs.stage ) + && ( pCheckpointMarker == rhs.pCheckpointMarker ); + } + + bool operator!=( CheckpointDataNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eCheckpointDataNV; + + public: + void* pNext = nullptr; + PipelineStageFlagBits stage; + void* pCheckpointMarker; + }; + static_assert( sizeof( CheckpointDataNV ) == sizeof( VkCheckpointDataNV ), "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); + } + + operator VkClearColorValue &() + { + 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 VkClearDepthStencilValue const&() const + { + return *reinterpret_cast( this ); + } + + operator VkClearDepthStencilValue &() + { + 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); + } + + operator VkClearValue &() + { + 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 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 VkClearAttachment const&() const + { + return *reinterpret_cast( this ); + } + + operator VkClearAttachment &() + { + return *reinterpret_cast( this ); + } + + ImageAspectFlags aspectMask; + uint32_t colorAttachment; + ClearValue clearValue; + }; + static_assert( sizeof( ClearAttachment ) == sizeof( VkClearAttachment ), "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 VkClearRect const&() const + { + return *reinterpret_cast( this ); + } + + operator VkClearRect &() + { + 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 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 VkIndirectCommandsTokenNVX const&() const + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsTokenNVX &() + { + 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 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 VkCmdProcessCommandsInfoNVX const&() const + { + return *reinterpret_cast( this ); + } + + operator VkCmdProcessCommandsInfoNVX &() + { + 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 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 VkCmdReserveSpaceForCommandsInfoNVX const&() const + { + return *reinterpret_cast( this ); + } + + operator VkCmdReserveSpaceForCommandsInfoNVX &() + { + 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 CoarseSampleLocationNV + { + CoarseSampleLocationNV( uint32_t pixelX_ = 0, + uint32_t pixelY_ = 0, + uint32_t sample_ = 0 ) + : pixelX( pixelX_ ) + , pixelY( pixelY_ ) + , sample( sample_ ) + {} + + CoarseSampleLocationNV( VkCoarseSampleLocationNV const & rhs ) + { + memcpy( this, &rhs, sizeof( CoarseSampleLocationNV ) ); + } + + CoarseSampleLocationNV& operator=( VkCoarseSampleLocationNV const & rhs ) + { + memcpy( this, &rhs, sizeof( CoarseSampleLocationNV ) ); + return *this; + } + + CoarseSampleLocationNV & setPixelX( uint32_t pixelX_ ) + { + pixelX = pixelX_; + return *this; + } + + CoarseSampleLocationNV & setPixelY( uint32_t pixelY_ ) + { + pixelY = pixelY_; + return *this; + } + + CoarseSampleLocationNV & setSample( uint32_t sample_ ) + { + sample = sample_; + return *this; + } + + operator VkCoarseSampleLocationNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkCoarseSampleLocationNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( CoarseSampleLocationNV const& rhs ) const + { + return ( pixelX == rhs.pixelX ) + && ( pixelY == rhs.pixelY ) + && ( sample == rhs.sample ); + } + + bool operator!=( CoarseSampleLocationNV const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t pixelX; + uint32_t pixelY; + uint32_t sample; + }; + static_assert( sizeof( CoarseSampleLocationNV ) == sizeof( VkCoarseSampleLocationNV ), "struct and wrapper have different size!" ); + + struct CoarseSampleOrderCustomNV + { + CoarseSampleOrderCustomNV( ShadingRatePaletteEntryNV shadingRate_ = ShadingRatePaletteEntryNV::eNoInvocations, + uint32_t sampleCount_ = 0, + uint32_t sampleLocationCount_ = 0, + const CoarseSampleLocationNV* pSampleLocations_ = nullptr ) + : shadingRate( shadingRate_ ) + , sampleCount( sampleCount_ ) + , sampleLocationCount( sampleLocationCount_ ) + , pSampleLocations( pSampleLocations_ ) + {} + + CoarseSampleOrderCustomNV( VkCoarseSampleOrderCustomNV const & rhs ) + { + memcpy( this, &rhs, sizeof( CoarseSampleOrderCustomNV ) ); + } + + CoarseSampleOrderCustomNV& operator=( VkCoarseSampleOrderCustomNV const & rhs ) + { + memcpy( this, &rhs, sizeof( CoarseSampleOrderCustomNV ) ); + return *this; + } + + CoarseSampleOrderCustomNV & setShadingRate( ShadingRatePaletteEntryNV shadingRate_ ) + { + shadingRate = shadingRate_; + return *this; + } + + CoarseSampleOrderCustomNV & setSampleCount( uint32_t sampleCount_ ) + { + sampleCount = sampleCount_; + return *this; + } + + CoarseSampleOrderCustomNV & setSampleLocationCount( uint32_t sampleLocationCount_ ) + { + sampleLocationCount = sampleLocationCount_; + return *this; + } + + CoarseSampleOrderCustomNV & setPSampleLocations( const CoarseSampleLocationNV* pSampleLocations_ ) + { + pSampleLocations = pSampleLocations_; + return *this; + } + + operator VkCoarseSampleOrderCustomNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkCoarseSampleOrderCustomNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( CoarseSampleOrderCustomNV const& rhs ) const + { + return ( shadingRate == rhs.shadingRate ) + && ( sampleCount == rhs.sampleCount ) + && ( sampleLocationCount == rhs.sampleLocationCount ) + && ( pSampleLocations == rhs.pSampleLocations ); + } + + bool operator!=( CoarseSampleOrderCustomNV const& rhs ) const + { + return !operator==( rhs ); + } + + ShadingRatePaletteEntryNV shadingRate; + uint32_t sampleCount; + uint32_t sampleLocationCount; + const CoarseSampleLocationNV* pSampleLocations; + }; + static_assert( sizeof( CoarseSampleOrderCustomNV ) == sizeof( VkCoarseSampleOrderCustomNV ), "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 VkCommandBufferAllocateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferAllocateInfo &() + { + 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 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 VkCommandBufferInheritanceInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceInfo &() + { + 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 VkCommandBufferBeginInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferBeginInfo &() + { + 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 CommandBufferInheritanceConditionalRenderingInfoEXT + { + CommandBufferInheritanceConditionalRenderingInfoEXT( Bool32 conditionalRenderingEnable_ = 0 ) + : conditionalRenderingEnable( conditionalRenderingEnable_ ) + {} + + CommandBufferInheritanceConditionalRenderingInfoEXT( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) ); + } + + CommandBufferInheritanceConditionalRenderingInfoEXT& operator=( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) ); + return *this; + } + + CommandBufferInheritanceConditionalRenderingInfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + CommandBufferInheritanceConditionalRenderingInfoEXT & setConditionalRenderingEnable( Bool32 conditionalRenderingEnable_ ) + { + conditionalRenderingEnable = conditionalRenderingEnable_; + return *this; + } + + operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceConditionalRenderingInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( CommandBufferInheritanceConditionalRenderingInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( conditionalRenderingEnable == rhs.conditionalRenderingEnable ); + } + + bool operator!=( CommandBufferInheritanceConditionalRenderingInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT; + + public: + const void* pNext = nullptr; + Bool32 conditionalRenderingEnable; + }; + static_assert( sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) == sizeof( VkCommandBufferInheritanceConditionalRenderingInfoEXT ), "struct and wrapper have different size!" ); + + 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 VkCommandPoolCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkCommandPoolCreateInfo &() + { + 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!" ); + + 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 VkSpecializationMapEntry const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSpecializationMapEntry &() + { + 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 VkSpecializationInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSpecializationInfo &() + { + 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!" ); + + 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 VkPipelineShaderStageCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineShaderStageCreateInfo &() + { + 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 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 VkComputePipelineCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkComputePipelineCreateInfo &() + { + 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!" ); + + struct ConditionalRenderingBeginInfoEXT + { + ConditionalRenderingBeginInfoEXT( Buffer buffer_ = Buffer(), + DeviceSize offset_ = 0, + ConditionalRenderingFlagsEXT flags_ = ConditionalRenderingFlagsEXT() ) + : buffer( buffer_ ) + , offset( offset_ ) + , flags( flags_ ) + {} + + ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ConditionalRenderingBeginInfoEXT ) ); + } + + ConditionalRenderingBeginInfoEXT& operator=( VkConditionalRenderingBeginInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ConditionalRenderingBeginInfoEXT ) ); + return *this; + } + + ConditionalRenderingBeginInfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ConditionalRenderingBeginInfoEXT & setBuffer( Buffer buffer_ ) + { + buffer = buffer_; + return *this; + } + + ConditionalRenderingBeginInfoEXT & setOffset( DeviceSize offset_ ) + { + offset = offset_; + return *this; + } + + ConditionalRenderingBeginInfoEXT & setFlags( ConditionalRenderingFlagsEXT flags_ ) + { + flags = flags_; + return *this; + } + + operator VkConditionalRenderingBeginInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkConditionalRenderingBeginInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( ConditionalRenderingBeginInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( buffer == rhs.buffer ) + && ( offset == rhs.offset ) + && ( flags == rhs.flags ); + } + + bool operator!=( ConditionalRenderingBeginInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eConditionalRenderingBeginInfoEXT; + + public: + const void* pNext = nullptr; + Buffer buffer; + DeviceSize offset; + ConditionalRenderingFlagsEXT flags; + }; + static_assert( sizeof( ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), "struct and wrapper have different size!" ); + + struct ConformanceVersionKHR + { + ConformanceVersionKHR( uint8_t major_ = 0, + uint8_t minor_ = 0, + uint8_t subminor_ = 0, + uint8_t patch_ = 0 ) + : major( major_ ) + , minor( minor_ ) + , subminor( subminor_ ) + , patch( patch_ ) + {} + + ConformanceVersionKHR( VkConformanceVersionKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ConformanceVersionKHR ) ); + } + + ConformanceVersionKHR& operator=( VkConformanceVersionKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ConformanceVersionKHR ) ); + return *this; + } + + ConformanceVersionKHR & setMajor( uint8_t major_ ) + { + major = major_; + return *this; + } + + ConformanceVersionKHR & setMinor( uint8_t minor_ ) + { + minor = minor_; + return *this; + } + + ConformanceVersionKHR & setSubminor( uint8_t subminor_ ) + { + subminor = subminor_; + return *this; + } + + ConformanceVersionKHR & setPatch( uint8_t patch_ ) + { + patch = patch_; + return *this; + } + + operator VkConformanceVersionKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkConformanceVersionKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( ConformanceVersionKHR const& rhs ) const + { + return ( major == rhs.major ) + && ( minor == rhs.minor ) + && ( subminor == rhs.subminor ) + && ( patch == rhs.patch ); + } + + bool operator!=( ConformanceVersionKHR const& rhs ) const + { + return !operator==( rhs ); + } + + uint8_t major; + uint8_t minor; + uint8_t subminor; + uint8_t patch; + }; + static_assert( sizeof( ConformanceVersionKHR ) == sizeof( VkConformanceVersionKHR ), "struct and wrapper have different size!" ); + + struct CooperativeMatrixPropertiesNV + { + CooperativeMatrixPropertiesNV( uint32_t MSize_ = 0, + uint32_t NSize_ = 0, + uint32_t KSize_ = 0, + ComponentTypeNV AType_ = ComponentTypeNV::eFloat16, + ComponentTypeNV BType_ = ComponentTypeNV::eFloat16, + ComponentTypeNV CType_ = ComponentTypeNV::eFloat16, + ComponentTypeNV DType_ = ComponentTypeNV::eFloat16, + ScopeNV scope_ = ScopeNV::eDevice ) + : MSize( MSize_ ) + , NSize( NSize_ ) + , KSize( KSize_ ) + , AType( AType_ ) + , BType( BType_ ) + , CType( CType_ ) + , DType( DType_ ) + , scope( scope_ ) + {} + + CooperativeMatrixPropertiesNV( VkCooperativeMatrixPropertiesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( CooperativeMatrixPropertiesNV ) ); + } + + CooperativeMatrixPropertiesNV& operator=( VkCooperativeMatrixPropertiesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( CooperativeMatrixPropertiesNV ) ); + return *this; + } + + CooperativeMatrixPropertiesNV & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + CooperativeMatrixPropertiesNV & setMSize( uint32_t MSize_ ) + { + MSize = MSize_; + return *this; + } + + CooperativeMatrixPropertiesNV & setNSize( uint32_t NSize_ ) + { + NSize = NSize_; + return *this; + } + + CooperativeMatrixPropertiesNV & setKSize( uint32_t KSize_ ) + { + KSize = KSize_; + return *this; + } + + CooperativeMatrixPropertiesNV & setAType( ComponentTypeNV AType_ ) + { + AType = AType_; + return *this; + } + + CooperativeMatrixPropertiesNV & setBType( ComponentTypeNV BType_ ) + { + BType = BType_; + return *this; + } + + CooperativeMatrixPropertiesNV & setCType( ComponentTypeNV CType_ ) + { + CType = CType_; + return *this; + } + + CooperativeMatrixPropertiesNV & setDType( ComponentTypeNV DType_ ) + { + DType = DType_; + return *this; + } + + CooperativeMatrixPropertiesNV & setScope( ScopeNV scope_ ) + { + scope = scope_; + return *this; + } + + operator VkCooperativeMatrixPropertiesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkCooperativeMatrixPropertiesNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( CooperativeMatrixPropertiesNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( MSize == rhs.MSize ) + && ( NSize == rhs.NSize ) + && ( KSize == rhs.KSize ) + && ( AType == rhs.AType ) + && ( BType == rhs.BType ) + && ( CType == rhs.CType ) + && ( DType == rhs.DType ) + && ( scope == rhs.scope ); + } + + bool operator!=( CooperativeMatrixPropertiesNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eCooperativeMatrixPropertiesNV; + + public: + void* pNext = nullptr; + uint32_t MSize; + uint32_t NSize; + uint32_t KSize; + ComponentTypeNV AType; + ComponentTypeNV BType; + ComponentTypeNV CType; + ComponentTypeNV DType; + ScopeNV scope; + }; + static_assert( sizeof( CooperativeMatrixPropertiesNV ) == sizeof( VkCooperativeMatrixPropertiesNV ), "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 VkCopyDescriptorSet const&() const + { + return *reinterpret_cast( this ); + } + + operator VkCopyDescriptorSet &() + { + 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!" ); + +#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 VkD3D12FenceSubmitInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkD3D12FenceSubmitInfoKHR &() + { + 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*/ + + struct DebugMarkerMarkerInfoEXT + { + DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr, + std::array const& color_ = { { 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 VkDebugMarkerMarkerInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDebugMarkerMarkerInfoEXT &() + { + 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 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 VkDebugMarkerObjectNameInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDebugMarkerObjectNameInfoEXT &() + { + 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 VkDebugMarkerObjectTagInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDebugMarkerObjectTagInfoEXT &() + { + 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!" ); + + 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 VkDebugReportCallbackCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDebugReportCallbackCreateInfoEXT &() + { + 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!" ); + + struct DebugUtilsLabelEXT + { + DebugUtilsLabelEXT( const char* pLabelName_ = nullptr, + std::array const& color_ = { { 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 VkDebugUtilsLabelEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDebugUtilsLabelEXT &() + { + 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 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 VkDebugUtilsObjectNameInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDebugUtilsObjectNameInfoEXT &() + { + 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 DebugUtilsMessengerCallbackDataEXT + { + DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataFlagsEXT flags_ = DebugUtilsMessengerCallbackDataFlagsEXT(), + const char* pMessageIdName_ = nullptr, + int32_t messageIdNumber_ = 0, + const char* pMessage_ = nullptr, + uint32_t queueLabelCount_ = 0, + const DebugUtilsLabelEXT* pQueueLabels_ = nullptr, + uint32_t cmdBufLabelCount_ = 0, + const DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr, + uint32_t objectCount_ = 0, + const 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( const DebugUtilsLabelEXT* pQueueLabels_ ) + { + pQueueLabels = pQueueLabels_; + return *this; + } + + DebugUtilsMessengerCallbackDataEXT & setCmdBufLabelCount( uint32_t cmdBufLabelCount_ ) + { + cmdBufLabelCount = cmdBufLabelCount_; + return *this; + } + + DebugUtilsMessengerCallbackDataEXT & setPCmdBufLabels( const DebugUtilsLabelEXT* pCmdBufLabels_ ) + { + pCmdBufLabels = pCmdBufLabels_; + return *this; + } + + DebugUtilsMessengerCallbackDataEXT & setObjectCount( uint32_t objectCount_ ) + { + objectCount = objectCount_; + return *this; + } + + DebugUtilsMessengerCallbackDataEXT & setPObjects( const DebugUtilsObjectNameInfoEXT* pObjects_ ) + { + pObjects = pObjects_; + return *this; + } + + operator VkDebugUtilsMessengerCallbackDataEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDebugUtilsMessengerCallbackDataEXT &() + { + 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; + const DebugUtilsLabelEXT* pQueueLabels; + uint32_t cmdBufLabelCount; + const DebugUtilsLabelEXT* pCmdBufLabels; + uint32_t objectCount; + const DebugUtilsObjectNameInfoEXT* pObjects; + }; + static_assert( sizeof( DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), "struct and wrapper have different size!" ); + + 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 VkDebugUtilsMessengerCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDebugUtilsMessengerCreateInfoEXT &() + { + 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!" ); + + 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 VkDebugUtilsObjectTagInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDebugUtilsObjectTagInfoEXT &() + { + 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 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 VkDedicatedAllocationBufferCreateInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDedicatedAllocationBufferCreateInfoNV &() + { + 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 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 VkDedicatedAllocationImageCreateInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDedicatedAllocationImageCreateInfoNV &() + { + 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 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 VkDedicatedAllocationMemoryAllocateInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDedicatedAllocationMemoryAllocateInfoNV &() + { + 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!" ); + + 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 VkDescriptorBufferInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorBufferInfo &() + { + 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 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 VkDescriptorImageInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorImageInfo &() + { + 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 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 VkDescriptorPoolSize const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorPoolSize &() + { + 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 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 VkDescriptorPoolCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorPoolCreateInfo &() + { + 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!" ); + + struct DescriptorPoolInlineUniformBlockCreateInfoEXT + { + DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = 0 ) + : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ ) + {} + + DescriptorPoolInlineUniformBlockCreateInfoEXT( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) ); + } + + DescriptorPoolInlineUniformBlockCreateInfoEXT& operator=( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) ); + return *this; + } + + DescriptorPoolInlineUniformBlockCreateInfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DescriptorPoolInlineUniformBlockCreateInfoEXT & setMaxInlineUniformBlockBindings( uint32_t maxInlineUniformBlockBindings_ ) + { + maxInlineUniformBlockBindings = maxInlineUniformBlockBindings_; + return *this; + } + + operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( DescriptorPoolInlineUniformBlockCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( maxInlineUniformBlockBindings == rhs.maxInlineUniformBlockBindings ); + } + + bool operator!=( DescriptorPoolInlineUniformBlockCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT; + + public: + const void* pNext = nullptr; + uint32_t maxInlineUniformBlockBindings; + }; + static_assert( sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) == sizeof( VkDescriptorPoolInlineUniformBlockCreateInfoEXT ), "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 VkDescriptorSetAllocateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetAllocateInfo &() + { + 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 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 VkDescriptorSetLayoutBinding const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutBinding &() + { + 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 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 VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutBindingFlagsCreateInfoEXT &() + { + 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!" ); + + 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 VkDescriptorSetLayoutCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutCreateInfo &() + { + 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!" ); + + struct DescriptorSetLayoutSupport + { + operator VkDescriptorSetLayoutSupport const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutSupport &() + { + 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!" ); + + 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 VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetVariableDescriptorCountAllocateInfoEXT &() + { + 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 VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetVariableDescriptorCountLayoutSupportEXT &() + { + 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 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 VkDescriptorUpdateTemplateEntry const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorUpdateTemplateEntry &() + { + 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!" ); + + 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( const 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 VkDescriptorUpdateTemplateCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorUpdateTemplateCreateInfo &() + { + 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: + const 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!" ); + + 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 VkDeviceQueueCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceQueueCreateInfo &() + { + 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 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 VkPhysicalDeviceFeatures const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFeatures &() + { + 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 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 VkDeviceCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceCreateInfo &() + { + 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 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 VkDeviceEventInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceEventInfoEXT &() + { + 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!" ); + + 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 VkDeviceGeneratedCommandsFeaturesNVX const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGeneratedCommandsFeaturesNVX &() + { + 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 VkDeviceGeneratedCommandsLimitsNVX const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGeneratedCommandsLimitsNVX &() + { + 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 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 VkDeviceGroupBindSparseInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupBindSparseInfo &() + { + 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!" ); + + 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 VkDeviceGroupCommandBufferBeginInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupCommandBufferBeginInfo &() + { + 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!" ); + + 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 VkDeviceGroupDeviceCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupDeviceCreateInfo &() + { + 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!" ); + + struct DeviceGroupPresentCapabilitiesKHR + { + operator VkDeviceGroupPresentCapabilitiesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupPresentCapabilitiesKHR &() + { + 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 VkDeviceGroupPresentInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupPresentInfoKHR &() + { + 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 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 VkDeviceGroupRenderPassBeginInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupRenderPassBeginInfo &() + { + 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!" ); + + 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 VkDeviceGroupSubmitInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupSubmitInfo &() + { + 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!" ); + + 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 VkDeviceGroupSwapchainCreateInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupSwapchainCreateInfoKHR &() + { + 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!" ); + + struct DeviceMemoryOverallocationCreateInfoAMD + { + DeviceMemoryOverallocationCreateInfoAMD( MemoryOverallocationBehaviorAMD overallocationBehavior_ = MemoryOverallocationBehaviorAMD::eDefault ) + : overallocationBehavior( overallocationBehavior_ ) + {} + + DeviceMemoryOverallocationCreateInfoAMD( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceMemoryOverallocationCreateInfoAMD ) ); + } + + DeviceMemoryOverallocationCreateInfoAMD& operator=( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) + { + memcpy( this, &rhs, sizeof( DeviceMemoryOverallocationCreateInfoAMD ) ); + return *this; + } + + DeviceMemoryOverallocationCreateInfoAMD & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DeviceMemoryOverallocationCreateInfoAMD & setOverallocationBehavior( MemoryOverallocationBehaviorAMD overallocationBehavior_ ) + { + overallocationBehavior = overallocationBehavior_; + return *this; + } + + operator VkDeviceMemoryOverallocationCreateInfoAMD const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceMemoryOverallocationCreateInfoAMD &() + { + return *reinterpret_cast( this ); + } + + bool operator==( DeviceMemoryOverallocationCreateInfoAMD const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( overallocationBehavior == rhs.overallocationBehavior ); + } + + bool operator!=( DeviceMemoryOverallocationCreateInfoAMD const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD; + + public: + const void* pNext = nullptr; + MemoryOverallocationBehaviorAMD overallocationBehavior; + }; + static_assert( sizeof( DeviceMemoryOverallocationCreateInfoAMD ) == sizeof( VkDeviceMemoryOverallocationCreateInfoAMD ), "struct and wrapper have different size!" ); + + 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 VkDeviceQueueGlobalPriorityCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceQueueGlobalPriorityCreateInfoEXT &() + { + 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!" ); + + 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 VkDeviceQueueInfo2 const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceQueueInfo2 &() + { + 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!" ); + + 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 VkDispatchIndirectCommand const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDispatchIndirectCommand &() + { + 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 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 VkDisplayEventInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDisplayEventInfoEXT &() + { + 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!" ); + + 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 VkDisplayModeParametersKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDisplayModeParametersKHR &() + { + 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 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 VkDisplayModeCreateInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDisplayModeCreateInfoKHR &() + { + 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 DisplayModePropertiesKHR + { + operator VkDisplayModePropertiesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDisplayModePropertiesKHR &() + { + 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 DisplayModeProperties2KHR + { + operator VkDisplayModeProperties2KHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDisplayModeProperties2KHR &() + { + 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 DisplayPlaneCapabilitiesKHR + { + operator VkDisplayPlaneCapabilitiesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPlaneCapabilitiesKHR &() + { + 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 VkDisplayPlaneCapabilities2KHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPlaneCapabilities2KHR &() + { + 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!" ); + + 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 VkDisplayPlaneInfo2KHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPlaneInfo2KHR &() + { + 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 DisplayPlanePropertiesKHR + { + operator VkDisplayPlanePropertiesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPlanePropertiesKHR &() + { + 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 DisplayPlaneProperties2KHR + { + operator VkDisplayPlaneProperties2KHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPlaneProperties2KHR &() + { + 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 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 VkDisplayPowerInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPowerInfoEXT &() + { + 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!" ); + + 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 VkDisplayPresentInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPresentInfoKHR &() + { + 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!" ); + + struct DisplayPropertiesKHR + { + operator VkDisplayPropertiesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPropertiesKHR &() + { + 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 DisplayProperties2KHR + { + operator VkDisplayProperties2KHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDisplayProperties2KHR &() + { + 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!" ); + + 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 VkDisplaySurfaceCreateInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDisplaySurfaceCreateInfoKHR &() + { + 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 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 VkDrawIndexedIndirectCommand const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDrawIndexedIndirectCommand &() + { + 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 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 VkDrawIndirectCommand const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDrawIndirectCommand &() + { + 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 DrawMeshTasksIndirectCommandNV + { + DrawMeshTasksIndirectCommandNV( uint32_t taskCount_ = 0, + uint32_t firstTask_ = 0 ) + : taskCount( taskCount_ ) + , firstTask( firstTask_ ) + {} + + DrawMeshTasksIndirectCommandNV( VkDrawMeshTasksIndirectCommandNV const & rhs ) + { + memcpy( this, &rhs, sizeof( DrawMeshTasksIndirectCommandNV ) ); + } + + DrawMeshTasksIndirectCommandNV& operator=( VkDrawMeshTasksIndirectCommandNV const & rhs ) + { + memcpy( this, &rhs, sizeof( DrawMeshTasksIndirectCommandNV ) ); + return *this; + } + + DrawMeshTasksIndirectCommandNV & setTaskCount( uint32_t taskCount_ ) + { + taskCount = taskCount_; + return *this; + } + + DrawMeshTasksIndirectCommandNV & setFirstTask( uint32_t firstTask_ ) + { + firstTask = firstTask_; + return *this; + } + + operator VkDrawMeshTasksIndirectCommandNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDrawMeshTasksIndirectCommandNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( DrawMeshTasksIndirectCommandNV const& rhs ) const + { + return ( taskCount == rhs.taskCount ) + && ( firstTask == rhs.firstTask ); + } + + bool operator!=( DrawMeshTasksIndirectCommandNV const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t taskCount; + uint32_t firstTask; + }; + static_assert( sizeof( DrawMeshTasksIndirectCommandNV ) == sizeof( VkDrawMeshTasksIndirectCommandNV ), "struct and wrapper have different size!" ); + + struct DrmFormatModifierPropertiesEXT + { + operator VkDrmFormatModifierPropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDrmFormatModifierPropertiesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( DrmFormatModifierPropertiesEXT const& rhs ) const + { + return ( drmFormatModifier == rhs.drmFormatModifier ) + && ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) + && ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures ); + } + + bool operator!=( DrmFormatModifierPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + FormatFeatureFlags drmFormatModifierTilingFeatures; + }; + static_assert( sizeof( DrmFormatModifierPropertiesEXT ) == sizeof( VkDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" ); + + struct DrmFormatModifierPropertiesListEXT + { + operator VkDrmFormatModifierPropertiesListEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkDrmFormatModifierPropertiesListEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( DrmFormatModifierPropertiesListEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( drmFormatModifierCount == rhs.drmFormatModifierCount ) + && ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties ); + } + + bool operator!=( DrmFormatModifierPropertiesListEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDrmFormatModifierPropertiesListEXT; + + public: + void* pNext = nullptr; + uint32_t drmFormatModifierCount; + DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties; + }; + static_assert( sizeof( DrmFormatModifierPropertiesListEXT ) == sizeof( VkDrmFormatModifierPropertiesListEXT ), "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 VkEventCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkEventCreateInfo &() + { + 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 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 VkExportFenceCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExportFenceCreateInfo &() + { + 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!" ); + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ExportFenceWin32HandleInfoKHR + { + ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, + DWORD dwAccess_ = 0, + LPCWSTR name_ = nullptr ) + : 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 VkExportFenceWin32HandleInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExportFenceWin32HandleInfoKHR &() + { + 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 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 VkExportMemoryAllocateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExportMemoryAllocateInfo &() + { + 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!" ); + + 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 VkExportMemoryAllocateInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExportMemoryAllocateInfoNV &() + { + 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_KHR + struct ExportMemoryWin32HandleInfoKHR + { + ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, + DWORD dwAccess_ = 0, + LPCWSTR name_ = nullptr ) + : 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 VkExportMemoryWin32HandleInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExportMemoryWin32HandleInfoKHR &() + { + 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 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 VkExportMemoryWin32HandleInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExportMemoryWin32HandleInfoNV &() + { + 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_KHR*/ + + 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 VkExportSemaphoreCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExportSemaphoreCreateInfo &() + { + 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!" ); + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ExportSemaphoreWin32HandleInfoKHR + { + ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, + DWORD dwAccess_ = 0, + LPCWSTR name_ = nullptr ) + : 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 VkExportSemaphoreWin32HandleInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExportSemaphoreWin32HandleInfoKHR &() + { + 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*/ + + struct ExtensionProperties + { + operator VkExtensionProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExtensionProperties &() + { + 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 ExternalMemoryProperties + { + operator VkExternalMemoryProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExternalMemoryProperties &() + { + 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!" ); + + struct ExternalBufferProperties + { + operator VkExternalBufferProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExternalBufferProperties &() + { + 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!" ); + + struct ExternalFenceProperties + { + operator VkExternalFenceProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExternalFenceProperties &() + { + 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!" ); + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + 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 VkExternalFormatANDROID const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExternalFormatANDROID &() + { + 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_KHR*/ + + struct ExternalImageFormatProperties + { + operator VkExternalImageFormatProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExternalImageFormatProperties &() + { + 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!" ); + + struct ImageFormatProperties + { + operator VkImageFormatProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageFormatProperties &() + { + 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 ExternalImageFormatPropertiesNV + { + operator VkExternalImageFormatPropertiesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExternalImageFormatPropertiesNV &() + { + 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!" ); + + 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 VkExternalMemoryBufferCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExternalMemoryBufferCreateInfo &() + { + 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!" ); + + 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 VkExternalMemoryImageCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExternalMemoryImageCreateInfo &() + { + 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!" ); + + 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 VkExternalMemoryImageCreateInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExternalMemoryImageCreateInfoNV &() + { + 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 ExternalSemaphoreProperties + { + operator VkExternalSemaphoreProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkExternalSemaphoreProperties &() + { + 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!" ); + + 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 VkFenceCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkFenceCreateInfo &() + { + 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!" ); + + 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 VkFenceGetFdInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkFenceGetFdInfoKHR &() + { + 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!" ); + +#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 VkFenceGetWin32HandleInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkFenceGetWin32HandleInfoKHR &() + { + 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 FilterCubicImageViewImageFormatPropertiesEXT + { + operator VkFilterCubicImageViewImageFormatPropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkFilterCubicImageViewImageFormatPropertiesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( FilterCubicImageViewImageFormatPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( filterCubic == rhs.filterCubic ) + && ( filterCubicMinmax == rhs.filterCubicMinmax ); + } + + bool operator!=( FilterCubicImageViewImageFormatPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eFilterCubicImageViewImageFormatPropertiesEXT; + + public: + void* pNext = nullptr; + Bool32 filterCubic; + Bool32 filterCubicMinmax; + }; + static_assert( sizeof( FilterCubicImageViewImageFormatPropertiesEXT ) == sizeof( VkFilterCubicImageViewImageFormatPropertiesEXT ), "struct and wrapper have different size!" ); + + struct FormatProperties + { + operator VkFormatProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkFormatProperties &() + { + 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 VkFormatProperties2 const&() const + { + return *reinterpret_cast( this ); + } + + operator VkFormatProperties2 &() + { + 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!" ); + + 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 VkFramebufferCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkFramebufferCreateInfo &() + { + 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 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 VkVertexInputBindingDescription const&() const + { + return *reinterpret_cast( this ); + } + + operator VkVertexInputBindingDescription &() + { + 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!" ); + + 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 VkVertexInputAttributeDescription const&() const + { + return *reinterpret_cast( this ); + } + + operator VkVertexInputAttributeDescription &() + { + 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!" ); + + 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 VkPipelineVertexInputStateCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineVertexInputStateCreateInfo &() + { + 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 VkPipelineInputAssemblyStateCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineInputAssemblyStateCreateInfo &() + { + 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 VkPipelineTessellationStateCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineTessellationStateCreateInfo &() + { + 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 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 VkViewport const&() const + { + return *reinterpret_cast( this ); + } + + operator VkViewport &() + { + 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 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 VkPipelineViewportStateCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportStateCreateInfo &() + { + 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 VkPipelineRasterizationStateCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationStateCreateInfo &() + { + 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 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 VkPipelineMultisampleStateCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineMultisampleStateCreateInfo &() + { + 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 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 VkStencilOpState const&() const + { + return *reinterpret_cast( this ); + } + + operator VkStencilOpState &() + { + 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!" ); + + 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 VkPipelineDepthStencilStateCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineDepthStencilStateCreateInfo &() + { + 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 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 VkPipelineColorBlendAttachmentState const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineColorBlendAttachmentState &() + { + 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 } } ) + : 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 VkPipelineColorBlendStateCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineColorBlendStateCreateInfo &() + { + 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!" ); + + 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 VkPipelineDynamicStateCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineDynamicStateCreateInfo &() + { + 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!" ); + + 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 VkGraphicsPipelineCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkGraphicsPipelineCreateInfo &() + { + 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 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 VkXYColorEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkXYColorEXT &() + { + 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 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 VkHdrMetadataEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkHdrMetadataEXT &() + { + 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!" ); + +#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 VkIOSSurfaceCreateInfoMVK const&() const + { + return *reinterpret_cast( this ); + } + + operator VkIOSSurfaceCreateInfoMVK &() + { + 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*/ + + struct ImageBlit + { + ImageBlit( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), + std::array const& srcOffsets_ = { { Offset3D() } }, + ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), + std::array const& dstOffsets_ = { { 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 VkImageBlit const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageBlit &() + { + 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 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 VkImageCopy const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageCopy &() + { + 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 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 VkImageCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageCreateInfo &() + { + 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 SubresourceLayout + { + operator VkSubresourceLayout const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSubresourceLayout &() + { + 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 ImageDrmFormatModifierExplicitCreateInfoEXT + { + ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = 0, + uint32_t drmFormatModifierPlaneCount_ = 0, + const SubresourceLayout* pPlaneLayouts_ = nullptr ) + : drmFormatModifier( drmFormatModifier_ ) + , drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ ) + , pPlaneLayouts( pPlaneLayouts_ ) + {} + + ImageDrmFormatModifierExplicitCreateInfoEXT( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) ); + } + + ImageDrmFormatModifierExplicitCreateInfoEXT& operator=( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) ); + return *this; + } + + ImageDrmFormatModifierExplicitCreateInfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImageDrmFormatModifierExplicitCreateInfoEXT & setDrmFormatModifier( uint64_t drmFormatModifier_ ) + { + drmFormatModifier = drmFormatModifier_; + return *this; + } + + ImageDrmFormatModifierExplicitCreateInfoEXT & setDrmFormatModifierPlaneCount( uint32_t drmFormatModifierPlaneCount_ ) + { + drmFormatModifierPlaneCount = drmFormatModifierPlaneCount_; + return *this; + } + + ImageDrmFormatModifierExplicitCreateInfoEXT & setPPlaneLayouts( const SubresourceLayout* pPlaneLayouts_ ) + { + pPlaneLayouts = pPlaneLayouts_; + return *this; + } + + operator VkImageDrmFormatModifierExplicitCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageDrmFormatModifierExplicitCreateInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( ImageDrmFormatModifierExplicitCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( drmFormatModifier == rhs.drmFormatModifier ) + && ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) + && ( pPlaneLayouts == rhs.pPlaneLayouts ); + } + + bool operator!=( ImageDrmFormatModifierExplicitCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT; + + public: + const void* pNext = nullptr; + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + const SubresourceLayout* pPlaneLayouts; + }; + static_assert( sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierExplicitCreateInfoEXT ), "struct and wrapper have different size!" ); + + struct ImageDrmFormatModifierListCreateInfoEXT + { + ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = 0, + const uint64_t* pDrmFormatModifiers_ = nullptr ) + : drmFormatModifierCount( drmFormatModifierCount_ ) + , pDrmFormatModifiers( pDrmFormatModifiers_ ) + {} + + ImageDrmFormatModifierListCreateInfoEXT( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageDrmFormatModifierListCreateInfoEXT ) ); + } + + ImageDrmFormatModifierListCreateInfoEXT& operator=( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageDrmFormatModifierListCreateInfoEXT ) ); + return *this; + } + + ImageDrmFormatModifierListCreateInfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImageDrmFormatModifierListCreateInfoEXT & setDrmFormatModifierCount( uint32_t drmFormatModifierCount_ ) + { + drmFormatModifierCount = drmFormatModifierCount_; + return *this; + } + + ImageDrmFormatModifierListCreateInfoEXT & setPDrmFormatModifiers( const uint64_t* pDrmFormatModifiers_ ) + { + pDrmFormatModifiers = pDrmFormatModifiers_; + return *this; + } + + operator VkImageDrmFormatModifierListCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageDrmFormatModifierListCreateInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( ImageDrmFormatModifierListCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( drmFormatModifierCount == rhs.drmFormatModifierCount ) + && ( pDrmFormatModifiers == rhs.pDrmFormatModifiers ); + } + + bool operator!=( ImageDrmFormatModifierListCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImageDrmFormatModifierListCreateInfoEXT; + + public: + const void* pNext = nullptr; + uint32_t drmFormatModifierCount; + const uint64_t* pDrmFormatModifiers; + }; + static_assert( sizeof( ImageDrmFormatModifierListCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierListCreateInfoEXT ), "struct and wrapper have different size!" ); + + struct ImageDrmFormatModifierPropertiesEXT + { + operator VkImageDrmFormatModifierPropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageDrmFormatModifierPropertiesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( ImageDrmFormatModifierPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( drmFormatModifier == rhs.drmFormatModifier ); + } + + bool operator!=( ImageDrmFormatModifierPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImageDrmFormatModifierPropertiesEXT; + + public: + void* pNext = nullptr; + uint64_t drmFormatModifier; + }; + static_assert( sizeof( ImageDrmFormatModifierPropertiesEXT ) == sizeof( VkImageDrmFormatModifierPropertiesEXT ), "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 VkImageFormatListCreateInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageFormatListCreateInfoKHR &() + { + 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 ImageFormatProperties2 + { + operator VkImageFormatProperties2 const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageFormatProperties2 &() + { + 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!" ); + + 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 VkImageSubresourceRange const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageSubresourceRange &() + { + 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 VkImageMemoryBarrier const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageMemoryBarrier &() + { + 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 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 VkImageMemoryRequirementsInfo2 const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageMemoryRequirementsInfo2 &() + { + 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!" ); + +#ifdef VK_USE_PLATFORM_FUCHSIA + struct ImagePipeSurfaceCreateInfoFUCHSIA + { + ImagePipeSurfaceCreateInfoFUCHSIA( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = ImagePipeSurfaceCreateFlagsFUCHSIA(), + zx_handle_t imagePipeHandle_ = 0 ) + : flags( flags_ ) + , imagePipeHandle( imagePipeHandle_ ) + {} + + ImagePipeSurfaceCreateInfoFUCHSIA( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) + { + memcpy( this, &rhs, sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) ); + } + + ImagePipeSurfaceCreateInfoFUCHSIA& operator=( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) + { + memcpy( this, &rhs, sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) ); + return *this; + } + + ImagePipeSurfaceCreateInfoFUCHSIA & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImagePipeSurfaceCreateInfoFUCHSIA & setFlags( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ ) + { + flags = flags_; + return *this; + } + + ImagePipeSurfaceCreateInfoFUCHSIA & setImagePipeHandle( zx_handle_t imagePipeHandle_ ) + { + imagePipeHandle = imagePipeHandle_; + return *this; + } + + operator VkImagePipeSurfaceCreateInfoFUCHSIA const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImagePipeSurfaceCreateInfoFUCHSIA &() + { + return *reinterpret_cast( this ); + } + + bool operator==( ImagePipeSurfaceCreateInfoFUCHSIA const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( imagePipeHandle == rhs.imagePipeHandle ); + } + + bool operator!=( ImagePipeSurfaceCreateInfoFUCHSIA const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA; + + public: + const void* pNext = nullptr; + ImagePipeSurfaceCreateFlagsFUCHSIA flags; + zx_handle_t imagePipeHandle; + }; + static_assert( sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) == sizeof( VkImagePipeSurfaceCreateInfoFUCHSIA ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + 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 VkImagePlaneMemoryRequirementsInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImagePlaneMemoryRequirementsInfo &() + { + 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!" ); + + 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 VkImageResolve const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageResolve &() + { + 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 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 VkImageSparseMemoryRequirementsInfo2 const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageSparseMemoryRequirementsInfo2 &() + { + 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!" ); + + struct ImageStencilUsageCreateInfoEXT + { + ImageStencilUsageCreateInfoEXT( ImageUsageFlags stencilUsage_ = ImageUsageFlags() ) + : stencilUsage( stencilUsage_ ) + {} + + ImageStencilUsageCreateInfoEXT( VkImageStencilUsageCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageStencilUsageCreateInfoEXT ) ); + } + + ImageStencilUsageCreateInfoEXT& operator=( VkImageStencilUsageCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageStencilUsageCreateInfoEXT ) ); + return *this; + } + + ImageStencilUsageCreateInfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImageStencilUsageCreateInfoEXT & setStencilUsage( ImageUsageFlags stencilUsage_ ) + { + stencilUsage = stencilUsage_; + return *this; + } + + operator VkImageStencilUsageCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageStencilUsageCreateInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( ImageStencilUsageCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( stencilUsage == rhs.stencilUsage ); + } + + bool operator!=( ImageStencilUsageCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImageStencilUsageCreateInfoEXT; + + public: + const void* pNext = nullptr; + ImageUsageFlags stencilUsage; + }; + static_assert( sizeof( ImageStencilUsageCreateInfoEXT ) == sizeof( VkImageStencilUsageCreateInfoEXT ), "struct and wrapper have different size!" ); + + 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 VkImageSwapchainCreateInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageSwapchainCreateInfoKHR &() + { + 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 ImageViewASTCDecodeModeEXT + { + ImageViewASTCDecodeModeEXT( Format decodeMode_ = Format::eUndefined ) + : decodeMode( decodeMode_ ) + {} + + ImageViewASTCDecodeModeEXT( VkImageViewASTCDecodeModeEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageViewASTCDecodeModeEXT ) ); + } + + ImageViewASTCDecodeModeEXT& operator=( VkImageViewASTCDecodeModeEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageViewASTCDecodeModeEXT ) ); + return *this; + } + + ImageViewASTCDecodeModeEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImageViewASTCDecodeModeEXT & setDecodeMode( Format decodeMode_ ) + { + decodeMode = decodeMode_; + return *this; + } + + operator VkImageViewASTCDecodeModeEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageViewASTCDecodeModeEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( ImageViewASTCDecodeModeEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( decodeMode == rhs.decodeMode ); + } + + bool operator!=( ImageViewASTCDecodeModeEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eImageViewAstcDecodeModeEXT; + + public: + const void* pNext = nullptr; + Format decodeMode; + }; + static_assert( sizeof( ImageViewASTCDecodeModeEXT ) == sizeof( VkImageViewASTCDecodeModeEXT ), "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 VkImageViewCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageViewCreateInfo &() + { + 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 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 VkImageViewUsageCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImageViewUsageCreateInfo &() + { + 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!" ); + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + 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 VkImportAndroidHardwareBufferInfoANDROID const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImportAndroidHardwareBufferInfoANDROID &() + { + 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_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 VkImportFenceFdInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImportFenceFdInfoKHR &() + { + 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!" ); + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ImportFenceWin32HandleInfoKHR + { + ImportFenceWin32HandleInfoKHR( Fence fence_ = Fence(), + FenceImportFlags flags_ = FenceImportFlags(), + ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd, + HANDLE handle_ = 0, + LPCWSTR name_ = nullptr ) + : 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 VkImportFenceWin32HandleInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImportFenceWin32HandleInfoKHR &() + { + 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 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 VkImportMemoryFdInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImportMemoryFdInfoKHR &() + { + 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 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 VkImportMemoryHostPointerInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImportMemoryHostPointerInfoEXT &() + { + 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!" ); + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ImportMemoryWin32HandleInfoKHR + { + ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, + HANDLE handle_ = 0, + LPCWSTR name_ = nullptr ) + : 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 VkImportMemoryWin32HandleInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImportMemoryWin32HandleInfoKHR &() + { + 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 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 VkImportMemoryWin32HandleInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImportMemoryWin32HandleInfoNV &() + { + 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_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 VkImportSemaphoreFdInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImportSemaphoreFdInfoKHR &() + { + 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!" ); + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ImportSemaphoreWin32HandleInfoKHR + { + ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), + SemaphoreImportFlags flags_ = SemaphoreImportFlags(), + ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, + HANDLE handle_ = 0, + LPCWSTR name_ = nullptr ) + : 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 VkImportSemaphoreWin32HandleInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkImportSemaphoreWin32HandleInfoKHR &() + { + 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 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 VkIndirectCommandsLayoutTokenNVX const&() const + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsLayoutTokenNVX &() + { + 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 VkIndirectCommandsLayoutCreateInfoNVX const&() const + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsLayoutCreateInfoNVX &() + { + 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!" ); + + 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 VkInputAttachmentAspectReference const&() const + { + return *reinterpret_cast( this ); + } + + operator VkInputAttachmentAspectReference &() + { + 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!" ); + + 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 VkInstanceCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkInstanceCreateInfo &() + { + 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 LayerProperties + { + operator VkLayerProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkLayerProperties &() + { + 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!" ); + +#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 VkMacOSSurfaceCreateInfoMVK const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMacOSSurfaceCreateInfoMVK &() + { + 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 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 VkMappedMemoryRange const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMappedMemoryRange &() + { + 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 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 VkMemoryAllocateFlagsInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMemoryAllocateFlagsInfo &() + { + 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!" ); + + 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 VkMemoryAllocateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMemoryAllocateInfo &() + { + 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 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 VkMemoryBarrier const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMemoryBarrier &() + { + 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 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 VkMemoryDedicatedAllocateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMemoryDedicatedAllocateInfo &() + { + 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!" ); + + struct MemoryDedicatedRequirements + { + operator VkMemoryDedicatedRequirements const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMemoryDedicatedRequirements &() + { + 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!" ); + + struct MemoryFdPropertiesKHR + { + operator VkMemoryFdPropertiesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMemoryFdPropertiesKHR &() + { + 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_ANDROID_KHR + 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 VkMemoryGetAndroidHardwareBufferInfoANDROID const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMemoryGetAndroidHardwareBufferInfoANDROID &() + { + 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_KHR*/ + + 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 VkMemoryGetFdInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMemoryGetFdInfoKHR &() + { + 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!" ); + +#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 VkMemoryGetWin32HandleInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMemoryGetWin32HandleInfoKHR &() + { + 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 MemoryHeap + { + operator VkMemoryHeap const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMemoryHeap &() + { + 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 MemoryHostPointerPropertiesEXT + { + operator VkMemoryHostPointerPropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMemoryHostPointerPropertiesEXT &() + { + 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 MemoryPriorityAllocateInfoEXT + { + MemoryPriorityAllocateInfoEXT( float priority_ = 0 ) + : priority( priority_ ) + {} + + MemoryPriorityAllocateInfoEXT( VkMemoryPriorityAllocateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryPriorityAllocateInfoEXT ) ); + } + + MemoryPriorityAllocateInfoEXT& operator=( VkMemoryPriorityAllocateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryPriorityAllocateInfoEXT ) ); + return *this; + } + + MemoryPriorityAllocateInfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + MemoryPriorityAllocateInfoEXT & setPriority( float priority_ ) + { + priority = priority_; + return *this; + } + + operator VkMemoryPriorityAllocateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMemoryPriorityAllocateInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( MemoryPriorityAllocateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( priority == rhs.priority ); + } + + bool operator!=( MemoryPriorityAllocateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eMemoryPriorityAllocateInfoEXT; + + public: + const void* pNext = nullptr; + float priority; + }; + static_assert( sizeof( MemoryPriorityAllocateInfoEXT ) == sizeof( VkMemoryPriorityAllocateInfoEXT ), "struct and wrapper have different size!" ); + + struct MemoryRequirements + { + operator VkMemoryRequirements const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMemoryRequirements &() + { + 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 MemoryRequirements2 + { + operator VkMemoryRequirements2 const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMemoryRequirements2 &() + { + 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!" ); + + struct MemoryType + { + operator VkMemoryType const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMemoryType &() + { + 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!" ); + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct MemoryWin32HandlePropertiesKHR + { + operator VkMemoryWin32HandlePropertiesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMemoryWin32HandlePropertiesKHR &() + { + 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 MultisamplePropertiesEXT + { + operator VkMultisamplePropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkMultisamplePropertiesEXT &() + { + 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 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 VkObjectTableCreateInfoNVX const&() const + { + return *reinterpret_cast( this ); + } + + operator VkObjectTableCreateInfoNVX &() + { + 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 VkObjectTableEntryNVX const&() const + { + return *reinterpret_cast( this ); + } + + operator VkObjectTableEntryNVX &() + { + 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 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 VkObjectTableDescriptorSetEntryNVX const&() const + { + return *reinterpret_cast( this ); + } + + operator VkObjectTableDescriptorSetEntryNVX &() + { + 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 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 VkObjectTableIndexBufferEntryNVX const&() const + { + return *reinterpret_cast( this ); + } + + operator VkObjectTableIndexBufferEntryNVX &() + { + 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 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 VkObjectTablePipelineEntryNVX const&() const + { + return *reinterpret_cast( this ); + } + + operator VkObjectTablePipelineEntryNVX &() + { + 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 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 VkObjectTablePushConstantEntryNVX const&() const + { + return *reinterpret_cast( this ); + } + + operator VkObjectTablePushConstantEntryNVX &() + { + 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!" ); + + 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 VkObjectTableVertexBufferEntryNVX const&() const + { + return *reinterpret_cast( this ); + } + + operator VkObjectTableVertexBufferEntryNVX &() + { + 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 PastPresentationTimingGOOGLE + { + operator VkPastPresentationTimingGOOGLE const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPastPresentationTimingGOOGLE &() + { + 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 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 VkPhysicalDevice16BitStorageFeatures const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevice16BitStorageFeatures &() + { + 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!" ); + + struct PhysicalDevice8BitStorageFeaturesKHR + { + PhysicalDevice8BitStorageFeaturesKHR( Bool32 storageBuffer8BitAccess_ = 0, + Bool32 uniformAndStorageBuffer8BitAccess_ = 0, + Bool32 storagePushConstant8_ = 0 ) + : storageBuffer8BitAccess( storageBuffer8BitAccess_ ) + , uniformAndStorageBuffer8BitAccess( uniformAndStorageBuffer8BitAccess_ ) + , storagePushConstant8( storagePushConstant8_ ) + {} + + PhysicalDevice8BitStorageFeaturesKHR( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDevice8BitStorageFeaturesKHR ) ); + } + + PhysicalDevice8BitStorageFeaturesKHR& operator=( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDevice8BitStorageFeaturesKHR ) ); + return *this; + } + + PhysicalDevice8BitStorageFeaturesKHR & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDevice8BitStorageFeaturesKHR & setStorageBuffer8BitAccess( Bool32 storageBuffer8BitAccess_ ) + { + storageBuffer8BitAccess = storageBuffer8BitAccess_; + return *this; + } + + PhysicalDevice8BitStorageFeaturesKHR & setUniformAndStorageBuffer8BitAccess( Bool32 uniformAndStorageBuffer8BitAccess_ ) + { + uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess_; + return *this; + } + + PhysicalDevice8BitStorageFeaturesKHR & setStoragePushConstant8( Bool32 storagePushConstant8_ ) + { + storagePushConstant8 = storagePushConstant8_; + return *this; + } + + operator VkPhysicalDevice8BitStorageFeaturesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevice8BitStorageFeaturesKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDevice8BitStorageFeaturesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( storageBuffer8BitAccess == rhs.storageBuffer8BitAccess ) + && ( uniformAndStorageBuffer8BitAccess == rhs.uniformAndStorageBuffer8BitAccess ) + && ( storagePushConstant8 == rhs.storagePushConstant8 ); + } + + bool operator!=( PhysicalDevice8BitStorageFeaturesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDevice8BitStorageFeaturesKHR; + + public: + void* pNext = nullptr; + Bool32 storageBuffer8BitAccess; + Bool32 uniformAndStorageBuffer8BitAccess; + Bool32 storagePushConstant8; + }; + static_assert( sizeof( PhysicalDevice8BitStorageFeaturesKHR ) == sizeof( VkPhysicalDevice8BitStorageFeaturesKHR ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceASTCDecodeFeaturesEXT + { + PhysicalDeviceASTCDecodeFeaturesEXT( Bool32 decodeModeSharedExponent_ = 0 ) + : decodeModeSharedExponent( decodeModeSharedExponent_ ) + {} + + PhysicalDeviceASTCDecodeFeaturesEXT( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) ); + } + + PhysicalDeviceASTCDecodeFeaturesEXT& operator=( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) ); + return *this; + } + + PhysicalDeviceASTCDecodeFeaturesEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceASTCDecodeFeaturesEXT & setDecodeModeSharedExponent( Bool32 decodeModeSharedExponent_ ) + { + decodeModeSharedExponent = decodeModeSharedExponent_; + return *this; + } + + operator VkPhysicalDeviceASTCDecodeFeaturesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceASTCDecodeFeaturesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceASTCDecodeFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( decodeModeSharedExponent == rhs.decodeModeSharedExponent ); + } + + bool operator!=( PhysicalDeviceASTCDecodeFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT; + + public: + void* pNext = nullptr; + Bool32 decodeModeSharedExponent; + }; + static_assert( sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) == sizeof( VkPhysicalDeviceASTCDecodeFeaturesEXT ), "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 VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &() + { + 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 VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &() + { + 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 PhysicalDeviceBufferAddressFeaturesEXT + { + PhysicalDeviceBufferAddressFeaturesEXT( Bool32 bufferDeviceAddress_ = 0, + Bool32 bufferDeviceAddressCaptureReplay_ = 0, + Bool32 bufferDeviceAddressMultiDevice_ = 0 ) + : bufferDeviceAddress( bufferDeviceAddress_ ) + , bufferDeviceAddressCaptureReplay( bufferDeviceAddressCaptureReplay_ ) + , bufferDeviceAddressMultiDevice( bufferDeviceAddressMultiDevice_ ) + {} + + PhysicalDeviceBufferAddressFeaturesEXT( VkPhysicalDeviceBufferAddressFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceBufferAddressFeaturesEXT ) ); + } + + PhysicalDeviceBufferAddressFeaturesEXT& operator=( VkPhysicalDeviceBufferAddressFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceBufferAddressFeaturesEXT ) ); + return *this; + } + + PhysicalDeviceBufferAddressFeaturesEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceBufferAddressFeaturesEXT & setBufferDeviceAddress( Bool32 bufferDeviceAddress_ ) + { + bufferDeviceAddress = bufferDeviceAddress_; + return *this; + } + + PhysicalDeviceBufferAddressFeaturesEXT & setBufferDeviceAddressCaptureReplay( Bool32 bufferDeviceAddressCaptureReplay_ ) + { + bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay_; + return *this; + } + + PhysicalDeviceBufferAddressFeaturesEXT & setBufferDeviceAddressMultiDevice( Bool32 bufferDeviceAddressMultiDevice_ ) + { + bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_; + return *this; + } + + operator VkPhysicalDeviceBufferAddressFeaturesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceBufferAddressFeaturesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceBufferAddressFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) + && ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) + && ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice ); + } + + bool operator!=( PhysicalDeviceBufferAddressFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceBufferAddressFeaturesEXT; + + public: + void* pNext = nullptr; + Bool32 bufferDeviceAddress; + Bool32 bufferDeviceAddressCaptureReplay; + Bool32 bufferDeviceAddressMultiDevice; + }; + static_assert( sizeof( PhysicalDeviceBufferAddressFeaturesEXT ) == sizeof( VkPhysicalDeviceBufferAddressFeaturesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceComputeShaderDerivativesFeaturesNV + { + PhysicalDeviceComputeShaderDerivativesFeaturesNV( Bool32 computeDerivativeGroupQuads_ = 0, + Bool32 computeDerivativeGroupLinear_ = 0 ) + : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ ) + , computeDerivativeGroupLinear( computeDerivativeGroupLinear_ ) + {} + + PhysicalDeviceComputeShaderDerivativesFeaturesNV( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) ); + } + + PhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) ); + return *this; + } + + PhysicalDeviceComputeShaderDerivativesFeaturesNV & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceComputeShaderDerivativesFeaturesNV & setComputeDerivativeGroupQuads( Bool32 computeDerivativeGroupQuads_ ) + { + computeDerivativeGroupQuads = computeDerivativeGroupQuads_; + return *this; + } + + PhysicalDeviceComputeShaderDerivativesFeaturesNV & setComputeDerivativeGroupLinear( Bool32 computeDerivativeGroupLinear_ ) + { + computeDerivativeGroupLinear = computeDerivativeGroupLinear_; + return *this; + } + + operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceComputeShaderDerivativesFeaturesNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( computeDerivativeGroupQuads == rhs.computeDerivativeGroupQuads ) + && ( computeDerivativeGroupLinear == rhs.computeDerivativeGroupLinear ); + } + + bool operator!=( PhysicalDeviceComputeShaderDerivativesFeaturesNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV; + + public: + void* pNext = nullptr; + Bool32 computeDerivativeGroupQuads; + Bool32 computeDerivativeGroupLinear; + }; + static_assert( sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) == sizeof( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceConditionalRenderingFeaturesEXT + { + PhysicalDeviceConditionalRenderingFeaturesEXT( Bool32 conditionalRendering_ = 0, + Bool32 inheritedConditionalRendering_ = 0 ) + : conditionalRendering( conditionalRendering_ ) + , inheritedConditionalRendering( inheritedConditionalRendering_ ) + {} + + PhysicalDeviceConditionalRenderingFeaturesEXT( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) ); + } + + PhysicalDeviceConditionalRenderingFeaturesEXT& operator=( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) ); + return *this; + } + + PhysicalDeviceConditionalRenderingFeaturesEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceConditionalRenderingFeaturesEXT & setConditionalRendering( Bool32 conditionalRendering_ ) + { + conditionalRendering = conditionalRendering_; + return *this; + } + + PhysicalDeviceConditionalRenderingFeaturesEXT & setInheritedConditionalRendering( Bool32 inheritedConditionalRendering_ ) + { + inheritedConditionalRendering = inheritedConditionalRendering_; + return *this; + } + + operator VkPhysicalDeviceConditionalRenderingFeaturesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceConditionalRenderingFeaturesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceConditionalRenderingFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( conditionalRendering == rhs.conditionalRendering ) + && ( inheritedConditionalRendering == rhs.inheritedConditionalRendering ); + } + + bool operator!=( PhysicalDeviceConditionalRenderingFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT; + + public: + void* pNext = nullptr; + Bool32 conditionalRendering; + Bool32 inheritedConditionalRendering; + }; + static_assert( sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) == sizeof( VkPhysicalDeviceConditionalRenderingFeaturesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceConservativeRasterizationPropertiesEXT + { + operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT &() + { + 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 PhysicalDeviceCooperativeMatrixFeaturesNV + { + PhysicalDeviceCooperativeMatrixFeaturesNV( Bool32 cooperativeMatrix_ = 0, + Bool32 cooperativeMatrixRobustBufferAccess_ = 0 ) + : cooperativeMatrix( cooperativeMatrix_ ) + , cooperativeMatrixRobustBufferAccess( cooperativeMatrixRobustBufferAccess_ ) + {} + + PhysicalDeviceCooperativeMatrixFeaturesNV( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceCooperativeMatrixFeaturesNV ) ); + } + + PhysicalDeviceCooperativeMatrixFeaturesNV& operator=( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceCooperativeMatrixFeaturesNV ) ); + return *this; + } + + PhysicalDeviceCooperativeMatrixFeaturesNV & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceCooperativeMatrixFeaturesNV & setCooperativeMatrix( Bool32 cooperativeMatrix_ ) + { + cooperativeMatrix = cooperativeMatrix_; + return *this; + } + + PhysicalDeviceCooperativeMatrixFeaturesNV & setCooperativeMatrixRobustBufferAccess( Bool32 cooperativeMatrixRobustBufferAccess_ ) + { + cooperativeMatrixRobustBufferAccess = cooperativeMatrixRobustBufferAccess_; + return *this; + } + + operator VkPhysicalDeviceCooperativeMatrixFeaturesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixFeaturesNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceCooperativeMatrixFeaturesNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( cooperativeMatrix == rhs.cooperativeMatrix ) + && ( cooperativeMatrixRobustBufferAccess == rhs.cooperativeMatrixRobustBufferAccess ); + } + + bool operator!=( PhysicalDeviceCooperativeMatrixFeaturesNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV; + + public: + void* pNext = nullptr; + Bool32 cooperativeMatrix; + Bool32 cooperativeMatrixRobustBufferAccess; + }; + static_assert( sizeof( PhysicalDeviceCooperativeMatrixFeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixFeaturesNV ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceCooperativeMatrixPropertiesNV + { + operator VkPhysicalDeviceCooperativeMatrixPropertiesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixPropertiesNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceCooperativeMatrixPropertiesNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( cooperativeMatrixSupportedStages == rhs.cooperativeMatrixSupportedStages ); + } + + bool operator!=( PhysicalDeviceCooperativeMatrixPropertiesNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV; + + public: + void* pNext = nullptr; + ShaderStageFlags cooperativeMatrixSupportedStages; + }; + static_assert( sizeof( PhysicalDeviceCooperativeMatrixPropertiesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixPropertiesNV ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceCornerSampledImageFeaturesNV + { + PhysicalDeviceCornerSampledImageFeaturesNV( Bool32 cornerSampledImage_ = 0 ) + : cornerSampledImage( cornerSampledImage_ ) + {} + + PhysicalDeviceCornerSampledImageFeaturesNV( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) ); + } + + PhysicalDeviceCornerSampledImageFeaturesNV& operator=( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) ); + return *this; + } + + PhysicalDeviceCornerSampledImageFeaturesNV & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceCornerSampledImageFeaturesNV & setCornerSampledImage( Bool32 cornerSampledImage_ ) + { + cornerSampledImage = cornerSampledImage_; + return *this; + } + + operator VkPhysicalDeviceCornerSampledImageFeaturesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCornerSampledImageFeaturesNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceCornerSampledImageFeaturesNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( cornerSampledImage == rhs.cornerSampledImage ); + } + + bool operator!=( PhysicalDeviceCornerSampledImageFeaturesNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV; + + public: + void* pNext = nullptr; + Bool32 cornerSampledImage; + }; + static_assert( sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV + { + PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( Bool32 dedicatedAllocationImageAliasing_ = 0 ) + : dedicatedAllocationImageAliasing( dedicatedAllocationImageAliasing_ ) + {} + + PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) ); + } + + PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& operator=( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) ); + return *this; + } + + PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & setDedicatedAllocationImageAliasing( Bool32 dedicatedAllocationImageAliasing_ ) + { + dedicatedAllocationImageAliasing = dedicatedAllocationImageAliasing_; + return *this; + } + + operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( dedicatedAllocationImageAliasing == rhs.dedicatedAllocationImageAliasing ); + } + + bool operator!=( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + + public: + void* pNext = nullptr; + Bool32 dedicatedAllocationImageAliasing; + }; + static_assert( sizeof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) == sizeof( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceDepthClipEnableFeaturesEXT + { + PhysicalDeviceDepthClipEnableFeaturesEXT( Bool32 depthClipEnable_ = 0 ) + : depthClipEnable( depthClipEnable_ ) + {} + + PhysicalDeviceDepthClipEnableFeaturesEXT( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceDepthClipEnableFeaturesEXT ) ); + } + + PhysicalDeviceDepthClipEnableFeaturesEXT& operator=( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceDepthClipEnableFeaturesEXT ) ); + return *this; + } + + PhysicalDeviceDepthClipEnableFeaturesEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceDepthClipEnableFeaturesEXT & setDepthClipEnable( Bool32 depthClipEnable_ ) + { + depthClipEnable = depthClipEnable_; + return *this; + } + + operator VkPhysicalDeviceDepthClipEnableFeaturesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthClipEnableFeaturesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceDepthClipEnableFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( depthClipEnable == rhs.depthClipEnable ); + } + + bool operator!=( PhysicalDeviceDepthClipEnableFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT; + + public: + void* pNext = nullptr; + Bool32 depthClipEnable; + }; + static_assert( sizeof( PhysicalDeviceDepthClipEnableFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClipEnableFeaturesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceDepthStencilResolvePropertiesKHR + { + operator VkPhysicalDeviceDepthStencilResolvePropertiesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthStencilResolvePropertiesKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceDepthStencilResolvePropertiesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( supportedDepthResolveModes == rhs.supportedDepthResolveModes ) + && ( supportedStencilResolveModes == rhs.supportedStencilResolveModes ) + && ( independentResolveNone == rhs.independentResolveNone ) + && ( independentResolve == rhs.independentResolve ); + } + + bool operator!=( PhysicalDeviceDepthStencilResolvePropertiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceDepthStencilResolvePropertiesKHR; + + public: + void* pNext = nullptr; + ResolveModeFlagsKHR supportedDepthResolveModes; + ResolveModeFlagsKHR supportedStencilResolveModes; + Bool32 independentResolveNone; + Bool32 independentResolve; + }; + static_assert( sizeof( PhysicalDeviceDepthStencilResolvePropertiesKHR ) == sizeof( VkPhysicalDeviceDepthStencilResolvePropertiesKHR ), "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 VkPhysicalDeviceDescriptorIndexingFeaturesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorIndexingFeaturesEXT &() + { + 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 VkPhysicalDeviceDescriptorIndexingPropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorIndexingPropertiesEXT &() + { + 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 PhysicalDeviceDiscardRectanglePropertiesEXT + { + operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDiscardRectanglePropertiesEXT &() + { + 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 PhysicalDeviceDriverPropertiesKHR + { + operator VkPhysicalDeviceDriverPropertiesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDriverPropertiesKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceDriverPropertiesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( driverID == rhs.driverID ) + && ( memcmp( driverName, rhs.driverName, VK_MAX_DRIVER_NAME_SIZE_KHR * sizeof( char ) ) == 0 ) + && ( memcmp( driverInfo, rhs.driverInfo, VK_MAX_DRIVER_INFO_SIZE_KHR * sizeof( char ) ) == 0 ) + && ( conformanceVersion == rhs.conformanceVersion ); + } + + bool operator!=( PhysicalDeviceDriverPropertiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceDriverPropertiesKHR; + + public: + void* pNext = nullptr; + DriverIdKHR driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE_KHR]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR]; + ConformanceVersionKHR conformanceVersion; + }; + static_assert( sizeof( PhysicalDeviceDriverPropertiesKHR ) == sizeof( VkPhysicalDeviceDriverPropertiesKHR ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceExclusiveScissorFeaturesNV + { + PhysicalDeviceExclusiveScissorFeaturesNV( Bool32 exclusiveScissor_ = 0 ) + : exclusiveScissor( exclusiveScissor_ ) + {} + + PhysicalDeviceExclusiveScissorFeaturesNV( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) ); + } + + PhysicalDeviceExclusiveScissorFeaturesNV& operator=( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) ); + return *this; + } + + PhysicalDeviceExclusiveScissorFeaturesNV & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceExclusiveScissorFeaturesNV & setExclusiveScissor( Bool32 exclusiveScissor_ ) + { + exclusiveScissor = exclusiveScissor_; + return *this; + } + + operator VkPhysicalDeviceExclusiveScissorFeaturesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExclusiveScissorFeaturesNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceExclusiveScissorFeaturesNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( exclusiveScissor == rhs.exclusiveScissor ); + } + + bool operator!=( PhysicalDeviceExclusiveScissorFeaturesNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV; + + public: + void* pNext = nullptr; + Bool32 exclusiveScissor; + }; + static_assert( sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) == sizeof( VkPhysicalDeviceExclusiveScissorFeaturesNV ), "struct and wrapper have different size!" ); + + 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 VkPhysicalDeviceExternalBufferInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalBufferInfo &() + { + 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!" ); + + 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 VkPhysicalDeviceExternalFenceInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalFenceInfo &() + { + 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!" ); + + 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 VkPhysicalDeviceExternalImageFormatInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalImageFormatInfo &() + { + 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!" ); + + struct PhysicalDeviceExternalMemoryHostPropertiesEXT + { + operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT &() + { + 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 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 VkPhysicalDeviceExternalSemaphoreInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalSemaphoreInfo &() + { + 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!" ); + + 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 VkPhysicalDeviceFeatures2 const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFeatures2 &() + { + 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!" ); + + struct PhysicalDeviceFloat16Int8FeaturesKHR + { + PhysicalDeviceFloat16Int8FeaturesKHR( Bool32 shaderFloat16_ = 0, + Bool32 shaderInt8_ = 0 ) + : shaderFloat16( shaderFloat16_ ) + , shaderInt8( shaderInt8_ ) + {} + + PhysicalDeviceFloat16Int8FeaturesKHR( VkPhysicalDeviceFloat16Int8FeaturesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceFloat16Int8FeaturesKHR ) ); + } + + PhysicalDeviceFloat16Int8FeaturesKHR& operator=( VkPhysicalDeviceFloat16Int8FeaturesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceFloat16Int8FeaturesKHR ) ); + return *this; + } + + PhysicalDeviceFloat16Int8FeaturesKHR & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceFloat16Int8FeaturesKHR & setShaderFloat16( Bool32 shaderFloat16_ ) + { + shaderFloat16 = shaderFloat16_; + return *this; + } + + PhysicalDeviceFloat16Int8FeaturesKHR & setShaderInt8( Bool32 shaderInt8_ ) + { + shaderInt8 = shaderInt8_; + return *this; + } + + operator VkPhysicalDeviceFloat16Int8FeaturesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFloat16Int8FeaturesKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceFloat16Int8FeaturesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( shaderFloat16 == rhs.shaderFloat16 ) + && ( shaderInt8 == rhs.shaderInt8 ); + } + + bool operator!=( PhysicalDeviceFloat16Int8FeaturesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceFloat16Int8FeaturesKHR; + + public: + void* pNext = nullptr; + Bool32 shaderFloat16; + Bool32 shaderInt8; + }; + static_assert( sizeof( PhysicalDeviceFloat16Int8FeaturesKHR ) == sizeof( VkPhysicalDeviceFloat16Int8FeaturesKHR ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceFloatControlsPropertiesKHR + { + operator VkPhysicalDeviceFloatControlsPropertiesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFloatControlsPropertiesKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceFloatControlsPropertiesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( separateDenormSettings == rhs.separateDenormSettings ) + && ( separateRoundingModeSettings == rhs.separateRoundingModeSettings ) + && ( shaderSignedZeroInfNanPreserveFloat16 == rhs.shaderSignedZeroInfNanPreserveFloat16 ) + && ( shaderSignedZeroInfNanPreserveFloat32 == rhs.shaderSignedZeroInfNanPreserveFloat32 ) + && ( shaderSignedZeroInfNanPreserveFloat64 == rhs.shaderSignedZeroInfNanPreserveFloat64 ) + && ( shaderDenormPreserveFloat16 == rhs.shaderDenormPreserveFloat16 ) + && ( shaderDenormPreserveFloat32 == rhs.shaderDenormPreserveFloat32 ) + && ( shaderDenormPreserveFloat64 == rhs.shaderDenormPreserveFloat64 ) + && ( shaderDenormFlushToZeroFloat16 == rhs.shaderDenormFlushToZeroFloat16 ) + && ( shaderDenormFlushToZeroFloat32 == rhs.shaderDenormFlushToZeroFloat32 ) + && ( shaderDenormFlushToZeroFloat64 == rhs.shaderDenormFlushToZeroFloat64 ) + && ( shaderRoundingModeRTEFloat16 == rhs.shaderRoundingModeRTEFloat16 ) + && ( shaderRoundingModeRTEFloat32 == rhs.shaderRoundingModeRTEFloat32 ) + && ( shaderRoundingModeRTEFloat64 == rhs.shaderRoundingModeRTEFloat64 ) + && ( shaderRoundingModeRTZFloat16 == rhs.shaderRoundingModeRTZFloat16 ) + && ( shaderRoundingModeRTZFloat32 == rhs.shaderRoundingModeRTZFloat32 ) + && ( shaderRoundingModeRTZFloat64 == rhs.shaderRoundingModeRTZFloat64 ); + } + + bool operator!=( PhysicalDeviceFloatControlsPropertiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceFloatControlsPropertiesKHR; + + public: + void* pNext = nullptr; + Bool32 separateDenormSettings; + Bool32 separateRoundingModeSettings; + Bool32 shaderSignedZeroInfNanPreserveFloat16; + Bool32 shaderSignedZeroInfNanPreserveFloat32; + Bool32 shaderSignedZeroInfNanPreserveFloat64; + Bool32 shaderDenormPreserveFloat16; + Bool32 shaderDenormPreserveFloat32; + Bool32 shaderDenormPreserveFloat64; + Bool32 shaderDenormFlushToZeroFloat16; + Bool32 shaderDenormFlushToZeroFloat32; + Bool32 shaderDenormFlushToZeroFloat64; + Bool32 shaderRoundingModeRTEFloat16; + Bool32 shaderRoundingModeRTEFloat32; + Bool32 shaderRoundingModeRTEFloat64; + Bool32 shaderRoundingModeRTZFloat16; + Bool32 shaderRoundingModeRTZFloat32; + Bool32 shaderRoundingModeRTZFloat64; + }; + static_assert( sizeof( PhysicalDeviceFloatControlsPropertiesKHR ) == sizeof( VkPhysicalDeviceFloatControlsPropertiesKHR ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceFragmentDensityMapFeaturesEXT + { + operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceFragmentDensityMapFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( fragmentDensityMap == rhs.fragmentDensityMap ) + && ( fragmentDensityMapDynamic == rhs.fragmentDensityMapDynamic ) + && ( fragmentDensityMapNonSubsampledImages == rhs.fragmentDensityMapNonSubsampledImages ); + } + + bool operator!=( PhysicalDeviceFragmentDensityMapFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT; + + public: + void* pNext = nullptr; + Bool32 fragmentDensityMap; + Bool32 fragmentDensityMapDynamic; + Bool32 fragmentDensityMapNonSubsampledImages; + }; + static_assert( sizeof( PhysicalDeviceFragmentDensityMapFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapFeaturesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceFragmentDensityMapPropertiesEXT + { + operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceFragmentDensityMapPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( minFragmentDensityTexelSize == rhs.minFragmentDensityTexelSize ) + && ( maxFragmentDensityTexelSize == rhs.maxFragmentDensityTexelSize ) + && ( fragmentDensityInvocations == rhs.fragmentDensityInvocations ); + } + + bool operator!=( PhysicalDeviceFragmentDensityMapPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT; + + public: + void* pNext = nullptr; + Extent2D minFragmentDensityTexelSize; + Extent2D maxFragmentDensityTexelSize; + Bool32 fragmentDensityInvocations; + }; + static_assert( sizeof( PhysicalDeviceFragmentDensityMapPropertiesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapPropertiesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV + { + PhysicalDeviceFragmentShaderBarycentricFeaturesNV( Bool32 fragmentShaderBarycentric_ = 0 ) + : fragmentShaderBarycentric( fragmentShaderBarycentric_ ) + {} + + PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) ); + } + + PhysicalDeviceFragmentShaderBarycentricFeaturesNV& operator=( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) ); + return *this; + } + + PhysicalDeviceFragmentShaderBarycentricFeaturesNV & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceFragmentShaderBarycentricFeaturesNV & setFragmentShaderBarycentric( Bool32 fragmentShaderBarycentric_ ) + { + fragmentShaderBarycentric = fragmentShaderBarycentric_; + return *this; + } + + operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( fragmentShaderBarycentric == rhs.fragmentShaderBarycentric ); + } + + bool operator!=( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV; + + public: + void* pNext = nullptr; + Bool32 fragmentShaderBarycentric; + }; + static_assert( sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) == sizeof( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceGroupProperties + { + operator VkPhysicalDeviceGroupProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGroupProperties &() + { + 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!" ); + + struct PhysicalDeviceIDProperties + { + operator VkPhysicalDeviceIDProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceIDProperties &() + { + 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!" ); + + struct PhysicalDeviceImageDrmFormatModifierInfoEXT + { + PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = 0, + SharingMode sharingMode_ = SharingMode::eExclusive, + uint32_t queueFamilyIndexCount_ = 0, + const uint32_t* pQueueFamilyIndices_ = nullptr ) + : drmFormatModifier( drmFormatModifier_ ) + , sharingMode( sharingMode_ ) + , queueFamilyIndexCount( queueFamilyIndexCount_ ) + , pQueueFamilyIndices( pQueueFamilyIndices_ ) + {} + + PhysicalDeviceImageDrmFormatModifierInfoEXT( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) ); + } + + PhysicalDeviceImageDrmFormatModifierInfoEXT& operator=( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) ); + return *this; + } + + PhysicalDeviceImageDrmFormatModifierInfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceImageDrmFormatModifierInfoEXT & setDrmFormatModifier( uint64_t drmFormatModifier_ ) + { + drmFormatModifier = drmFormatModifier_; + return *this; + } + + PhysicalDeviceImageDrmFormatModifierInfoEXT & setSharingMode( SharingMode sharingMode_ ) + { + sharingMode = sharingMode_; + return *this; + } + + PhysicalDeviceImageDrmFormatModifierInfoEXT & setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) + { + queueFamilyIndexCount = queueFamilyIndexCount_; + return *this; + } + + PhysicalDeviceImageDrmFormatModifierInfoEXT & setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ ) + { + pQueueFamilyIndices = pQueueFamilyIndices_; + return *this; + } + + operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceImageDrmFormatModifierInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( drmFormatModifier == rhs.drmFormatModifier ) + && ( sharingMode == rhs.sharingMode ) + && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) + && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ); + } + + bool operator!=( PhysicalDeviceImageDrmFormatModifierInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT; + + public: + const void* pNext = nullptr; + uint64_t drmFormatModifier; + SharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + }; + static_assert( sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) == sizeof( VkPhysicalDeviceImageDrmFormatModifierInfoEXT ), "struct and wrapper have different size!" ); + + 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 VkPhysicalDeviceImageFormatInfo2 const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageFormatInfo2 &() + { + 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!" ); + + struct PhysicalDeviceImageViewImageFormatInfoEXT + { + PhysicalDeviceImageViewImageFormatInfoEXT( ImageViewType imageViewType_ = ImageViewType::e1D ) + : imageViewType( imageViewType_ ) + {} + + PhysicalDeviceImageViewImageFormatInfoEXT( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceImageViewImageFormatInfoEXT ) ); + } + + PhysicalDeviceImageViewImageFormatInfoEXT& operator=( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceImageViewImageFormatInfoEXT ) ); + return *this; + } + + PhysicalDeviceImageViewImageFormatInfoEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceImageViewImageFormatInfoEXT & setImageViewType( ImageViewType imageViewType_ ) + { + imageViewType = imageViewType_; + return *this; + } + + operator VkPhysicalDeviceImageViewImageFormatInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageViewImageFormatInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceImageViewImageFormatInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( imageViewType == rhs.imageViewType ); + } + + bool operator!=( PhysicalDeviceImageViewImageFormatInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT; + + public: + void* pNext = nullptr; + ImageViewType imageViewType; + }; + static_assert( sizeof( PhysicalDeviceImageViewImageFormatInfoEXT ) == sizeof( VkPhysicalDeviceImageViewImageFormatInfoEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceInlineUniformBlockFeaturesEXT + { + PhysicalDeviceInlineUniformBlockFeaturesEXT( Bool32 inlineUniformBlock_ = 0, + Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = 0 ) + : inlineUniformBlock( inlineUniformBlock_ ) + , descriptorBindingInlineUniformBlockUpdateAfterBind( descriptorBindingInlineUniformBlockUpdateAfterBind_ ) + {} + + PhysicalDeviceInlineUniformBlockFeaturesEXT( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) ); + } + + PhysicalDeviceInlineUniformBlockFeaturesEXT& operator=( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) ); + return *this; + } + + PhysicalDeviceInlineUniformBlockFeaturesEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceInlineUniformBlockFeaturesEXT & setInlineUniformBlock( Bool32 inlineUniformBlock_ ) + { + inlineUniformBlock = inlineUniformBlock_; + return *this; + } + + PhysicalDeviceInlineUniformBlockFeaturesEXT & setDescriptorBindingInlineUniformBlockUpdateAfterBind( Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ ) + { + descriptorBindingInlineUniformBlockUpdateAfterBind = descriptorBindingInlineUniformBlockUpdateAfterBind_; + return *this; + } + + operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceInlineUniformBlockFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( inlineUniformBlock == rhs.inlineUniformBlock ) + && ( descriptorBindingInlineUniformBlockUpdateAfterBind == rhs.descriptorBindingInlineUniformBlockUpdateAfterBind ); + } + + bool operator!=( PhysicalDeviceInlineUniformBlockFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT; + + public: + void* pNext = nullptr; + Bool32 inlineUniformBlock; + Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind; + }; + static_assert( sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockFeaturesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceInlineUniformBlockPropertiesEXT + { + operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceInlineUniformBlockPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( maxInlineUniformBlockSize == rhs.maxInlineUniformBlockSize ) + && ( maxPerStageDescriptorInlineUniformBlocks == rhs.maxPerStageDescriptorInlineUniformBlocks ) + && ( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks == rhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ) + && ( maxDescriptorSetInlineUniformBlocks == rhs.maxDescriptorSetInlineUniformBlocks ) + && ( maxDescriptorSetUpdateAfterBindInlineUniformBlocks == rhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); + } + + bool operator!=( PhysicalDeviceInlineUniformBlockPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT; + + public: + void* pNext = nullptr; + uint32_t maxInlineUniformBlockSize; + uint32_t maxPerStageDescriptorInlineUniformBlocks; + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + uint32_t maxDescriptorSetInlineUniformBlocks; + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + }; + static_assert( sizeof( PhysicalDeviceInlineUniformBlockPropertiesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockPropertiesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceLimits + { + operator VkPhysicalDeviceLimits const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLimits &() + { + 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 PhysicalDeviceMaintenance3Properties + { + operator VkPhysicalDeviceMaintenance3Properties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance3Properties &() + { + 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!" ); + + struct PhysicalDeviceMemoryBudgetPropertiesEXT + { + operator VkPhysicalDeviceMemoryBudgetPropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryBudgetPropertiesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceMemoryBudgetPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memcmp( heapBudget, rhs.heapBudget, VK_MAX_MEMORY_HEAPS * sizeof( DeviceSize ) ) == 0 ) + && ( memcmp( heapUsage, rhs.heapUsage, VK_MAX_MEMORY_HEAPS * sizeof( DeviceSize ) ) == 0 ); + } + + bool operator!=( PhysicalDeviceMemoryBudgetPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT; + + public: + void* pNext = nullptr; + DeviceSize heapBudget[VK_MAX_MEMORY_HEAPS]; + DeviceSize heapUsage[VK_MAX_MEMORY_HEAPS]; + }; + static_assert( sizeof( PhysicalDeviceMemoryBudgetPropertiesEXT ) == sizeof( VkPhysicalDeviceMemoryBudgetPropertiesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceMemoryPriorityFeaturesEXT + { + PhysicalDeviceMemoryPriorityFeaturesEXT( Bool32 memoryPriority_ = 0 ) + : memoryPriority( memoryPriority_ ) + {} + + PhysicalDeviceMemoryPriorityFeaturesEXT( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) ); + } + + PhysicalDeviceMemoryPriorityFeaturesEXT& operator=( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) ); + return *this; + } + + PhysicalDeviceMemoryPriorityFeaturesEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceMemoryPriorityFeaturesEXT & setMemoryPriority( Bool32 memoryPriority_ ) + { + memoryPriority = memoryPriority_; + return *this; + } + + operator VkPhysicalDeviceMemoryPriorityFeaturesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryPriorityFeaturesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceMemoryPriorityFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memoryPriority == rhs.memoryPriority ); + } + + bool operator!=( PhysicalDeviceMemoryPriorityFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT; + + public: + void* pNext = nullptr; + Bool32 memoryPriority; + }; + static_assert( sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) == sizeof( VkPhysicalDeviceMemoryPriorityFeaturesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceMemoryProperties + { + operator VkPhysicalDeviceMemoryProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryProperties &() + { + 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 VkPhysicalDeviceMemoryProperties2 const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryProperties2 &() + { + 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!" ); + + struct PhysicalDeviceMeshShaderFeaturesNV + { + PhysicalDeviceMeshShaderFeaturesNV( Bool32 taskShader_ = 0, + Bool32 meshShader_ = 0 ) + : taskShader( taskShader_ ) + , meshShader( meshShader_ ) + {} + + PhysicalDeviceMeshShaderFeaturesNV( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderFeaturesNV ) ); + } + + PhysicalDeviceMeshShaderFeaturesNV& operator=( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderFeaturesNV ) ); + return *this; + } + + PhysicalDeviceMeshShaderFeaturesNV & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceMeshShaderFeaturesNV & setTaskShader( Bool32 taskShader_ ) + { + taskShader = taskShader_; + return *this; + } + + PhysicalDeviceMeshShaderFeaturesNV & setMeshShader( Bool32 meshShader_ ) + { + meshShader = meshShader_; + return *this; + } + + operator VkPhysicalDeviceMeshShaderFeaturesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMeshShaderFeaturesNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceMeshShaderFeaturesNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( taskShader == rhs.taskShader ) + && ( meshShader == rhs.meshShader ); + } + + bool operator!=( PhysicalDeviceMeshShaderFeaturesNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV; + + public: + void* pNext = nullptr; + Bool32 taskShader; + Bool32 meshShader; + }; + static_assert( sizeof( PhysicalDeviceMeshShaderFeaturesNV ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesNV ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceMeshShaderPropertiesNV + { + operator VkPhysicalDeviceMeshShaderPropertiesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMeshShaderPropertiesNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceMeshShaderPropertiesNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( maxDrawMeshTasksCount == rhs.maxDrawMeshTasksCount ) + && ( maxTaskWorkGroupInvocations == rhs.maxTaskWorkGroupInvocations ) + && ( memcmp( maxTaskWorkGroupSize, rhs.maxTaskWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 ) + && ( maxTaskTotalMemorySize == rhs.maxTaskTotalMemorySize ) + && ( maxTaskOutputCount == rhs.maxTaskOutputCount ) + && ( maxMeshWorkGroupInvocations == rhs.maxMeshWorkGroupInvocations ) + && ( memcmp( maxMeshWorkGroupSize, rhs.maxMeshWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 ) + && ( maxMeshTotalMemorySize == rhs.maxMeshTotalMemorySize ) + && ( maxMeshOutputVertices == rhs.maxMeshOutputVertices ) + && ( maxMeshOutputPrimitives == rhs.maxMeshOutputPrimitives ) + && ( maxMeshMultiviewViewCount == rhs.maxMeshMultiviewViewCount ) + && ( meshOutputPerVertexGranularity == rhs.meshOutputPerVertexGranularity ) + && ( meshOutputPerPrimitiveGranularity == rhs.meshOutputPerPrimitiveGranularity ); + } + + bool operator!=( PhysicalDeviceMeshShaderPropertiesNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV; + + public: + void* pNext = nullptr; + uint32_t maxDrawMeshTasksCount; + uint32_t maxTaskWorkGroupInvocations; + uint32_t maxTaskWorkGroupSize[3]; + uint32_t maxTaskTotalMemorySize; + uint32_t maxTaskOutputCount; + uint32_t maxMeshWorkGroupInvocations; + uint32_t maxMeshWorkGroupSize[3]; + uint32_t maxMeshTotalMemorySize; + uint32_t maxMeshOutputVertices; + uint32_t maxMeshOutputPrimitives; + uint32_t maxMeshMultiviewViewCount; + uint32_t meshOutputPerVertexGranularity; + uint32_t meshOutputPerPrimitiveGranularity; + }; + static_assert( sizeof( PhysicalDeviceMeshShaderPropertiesNV ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesNV ), "struct and wrapper have different size!" ); + + 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 VkPhysicalDeviceMultiviewFeatures const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiviewFeatures &() + { + 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!" ); + + struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + { + operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX &() + { + 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 PhysicalDeviceMultiviewProperties + { + operator VkPhysicalDeviceMultiviewProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiviewProperties &() + { + 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!" ); + + struct PhysicalDevicePCIBusInfoPropertiesEXT + { + operator VkPhysicalDevicePCIBusInfoPropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePCIBusInfoPropertiesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDevicePCIBusInfoPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( pciDomain == rhs.pciDomain ) + && ( pciBus == rhs.pciBus ) + && ( pciDevice == rhs.pciDevice ) + && ( pciFunction == rhs.pciFunction ); + } + + bool operator!=( PhysicalDevicePCIBusInfoPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT; + + public: + void* pNext = nullptr; + uint32_t pciDomain; + uint32_t pciBus; + uint32_t pciDevice; + uint32_t pciFunction; + }; + static_assert( sizeof( PhysicalDevicePCIBusInfoPropertiesEXT ) == sizeof( VkPhysicalDevicePCIBusInfoPropertiesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDevicePointClippingProperties + { + operator VkPhysicalDevicePointClippingProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePointClippingProperties &() + { + 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!" ); + + struct PhysicalDeviceSparseProperties + { + operator VkPhysicalDeviceSparseProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSparseProperties &() + { + 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 PhysicalDeviceProperties + { + operator VkPhysicalDeviceProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProperties &() + { + 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 VkPhysicalDeviceProperties2 const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProperties2 &() + { + 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!" ); + + 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 VkPhysicalDeviceProtectedMemoryFeatures const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProtectedMemoryFeatures &() + { + 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 + { + operator VkPhysicalDeviceProtectedMemoryProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProtectedMemoryProperties &() + { + 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 PhysicalDevicePushDescriptorPropertiesKHR + { + operator VkPhysicalDevicePushDescriptorPropertiesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePushDescriptorPropertiesKHR &() + { + 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 PhysicalDeviceRayTracingPropertiesNV + { + operator VkPhysicalDeviceRayTracingPropertiesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingPropertiesNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceRayTracingPropertiesNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( shaderGroupHandleSize == rhs.shaderGroupHandleSize ) + && ( maxRecursionDepth == rhs.maxRecursionDepth ) + && ( maxShaderGroupStride == rhs.maxShaderGroupStride ) + && ( shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment ) + && ( maxGeometryCount == rhs.maxGeometryCount ) + && ( maxInstanceCount == rhs.maxInstanceCount ) + && ( maxTriangleCount == rhs.maxTriangleCount ) + && ( maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures ); + } + + bool operator!=( PhysicalDeviceRayTracingPropertiesNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesNV; + + public: + void* pNext = nullptr; + uint32_t shaderGroupHandleSize; + uint32_t maxRecursionDepth; + uint32_t maxShaderGroupStride; + uint32_t shaderGroupBaseAlignment; + uint64_t maxGeometryCount; + uint64_t maxInstanceCount; + uint64_t maxTriangleCount; + uint32_t maxDescriptorSetAccelerationStructures; + }; + static_assert( sizeof( PhysicalDeviceRayTracingPropertiesNV ) == sizeof( VkPhysicalDeviceRayTracingPropertiesNV ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV + { + PhysicalDeviceRepresentativeFragmentTestFeaturesNV( Bool32 representativeFragmentTest_ = 0 ) + : representativeFragmentTest( representativeFragmentTest_ ) + {} + + PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) ); + } + + PhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) ); + return *this; + } + + PhysicalDeviceRepresentativeFragmentTestFeaturesNV & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceRepresentativeFragmentTestFeaturesNV & setRepresentativeFragmentTest( Bool32 representativeFragmentTest_ ) + { + representativeFragmentTest = representativeFragmentTest_; + return *this; + } + + operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( representativeFragmentTest == rhs.representativeFragmentTest ); + } + + bool operator!=( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV; + + public: + void* pNext = nullptr; + Bool32 representativeFragmentTest; + }; + static_assert( sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) == sizeof( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceSampleLocationsPropertiesEXT + { + operator VkPhysicalDeviceSampleLocationsPropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSampleLocationsPropertiesEXT &() + { + 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!" ); + + struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT + { + operator VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT &() + { + 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 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 VkPhysicalDeviceSamplerYcbcrConversionFeatures const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSamplerYcbcrConversionFeatures &() + { + 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!" ); + + struct PhysicalDeviceScalarBlockLayoutFeaturesEXT + { + PhysicalDeviceScalarBlockLayoutFeaturesEXT( Bool32 scalarBlockLayout_ = 0 ) + : scalarBlockLayout( scalarBlockLayout_ ) + {} + + PhysicalDeviceScalarBlockLayoutFeaturesEXT( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) ); + } + + PhysicalDeviceScalarBlockLayoutFeaturesEXT& operator=( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) ); + return *this; + } + + PhysicalDeviceScalarBlockLayoutFeaturesEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceScalarBlockLayoutFeaturesEXT & setScalarBlockLayout( Bool32 scalarBlockLayout_ ) + { + scalarBlockLayout = scalarBlockLayout_; + return *this; + } + + operator VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceScalarBlockLayoutFeaturesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceScalarBlockLayoutFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( scalarBlockLayout == rhs.scalarBlockLayout ); + } + + bool operator!=( PhysicalDeviceScalarBlockLayoutFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT; + + public: + void* pNext = nullptr; + Bool32 scalarBlockLayout; + }; + static_assert( sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) == sizeof( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceShaderAtomicInt64FeaturesKHR + { + PhysicalDeviceShaderAtomicInt64FeaturesKHR( Bool32 shaderBufferInt64Atomics_ = 0, + Bool32 shaderSharedInt64Atomics_ = 0 ) + : shaderBufferInt64Atomics( shaderBufferInt64Atomics_ ) + , shaderSharedInt64Atomics( shaderSharedInt64Atomics_ ) + {} + + PhysicalDeviceShaderAtomicInt64FeaturesKHR( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) ); + } + + PhysicalDeviceShaderAtomicInt64FeaturesKHR& operator=( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) ); + return *this; + } + + PhysicalDeviceShaderAtomicInt64FeaturesKHR & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceShaderAtomicInt64FeaturesKHR & setShaderBufferInt64Atomics( Bool32 shaderBufferInt64Atomics_ ) + { + shaderBufferInt64Atomics = shaderBufferInt64Atomics_; + return *this; + } + + PhysicalDeviceShaderAtomicInt64FeaturesKHR & setShaderSharedInt64Atomics( Bool32 shaderSharedInt64Atomics_ ) + { + shaderSharedInt64Atomics = shaderSharedInt64Atomics_; + return *this; + } + + operator VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAtomicInt64FeaturesKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceShaderAtomicInt64FeaturesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics ) + && ( shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics ); + } + + bool operator!=( PhysicalDeviceShaderAtomicInt64FeaturesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR; + + public: + void* pNext = nullptr; + Bool32 shaderBufferInt64Atomics; + Bool32 shaderSharedInt64Atomics; + }; + static_assert( sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceShaderCorePropertiesAMD + { + operator VkPhysicalDeviceShaderCorePropertiesAMD const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderCorePropertiesAMD &() + { + 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 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 VkPhysicalDeviceShaderDrawParameterFeatures const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderDrawParameterFeatures &() + { + 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 PhysicalDeviceShaderImageFootprintFeaturesNV + { + PhysicalDeviceShaderImageFootprintFeaturesNV( Bool32 imageFootprint_ = 0 ) + : imageFootprint( imageFootprint_ ) + {} + + PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) ); + } + + PhysicalDeviceShaderImageFootprintFeaturesNV& operator=( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) ); + return *this; + } + + PhysicalDeviceShaderImageFootprintFeaturesNV & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceShaderImageFootprintFeaturesNV & setImageFootprint( Bool32 imageFootprint_ ) + { + imageFootprint = imageFootprint_; + return *this; + } + + operator VkPhysicalDeviceShaderImageFootprintFeaturesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderImageFootprintFeaturesNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceShaderImageFootprintFeaturesNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( imageFootprint == rhs.imageFootprint ); + } + + bool operator!=( PhysicalDeviceShaderImageFootprintFeaturesNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV; + + public: + void* pNext = nullptr; + Bool32 imageFootprint; + }; + static_assert( sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) == sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceShadingRateImageFeaturesNV + { + PhysicalDeviceShadingRateImageFeaturesNV( Bool32 shadingRateImage_ = 0, + Bool32 shadingRateCoarseSampleOrder_ = 0 ) + : shadingRateImage( shadingRateImage_ ) + , shadingRateCoarseSampleOrder( shadingRateCoarseSampleOrder_ ) + {} + + PhysicalDeviceShadingRateImageFeaturesNV( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) ); + } + + PhysicalDeviceShadingRateImageFeaturesNV& operator=( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) ); + return *this; + } + + PhysicalDeviceShadingRateImageFeaturesNV & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceShadingRateImageFeaturesNV & setShadingRateImage( Bool32 shadingRateImage_ ) + { + shadingRateImage = shadingRateImage_; + return *this; + } + + PhysicalDeviceShadingRateImageFeaturesNV & setShadingRateCoarseSampleOrder( Bool32 shadingRateCoarseSampleOrder_ ) + { + shadingRateCoarseSampleOrder = shadingRateCoarseSampleOrder_; + return *this; + } + + operator VkPhysicalDeviceShadingRateImageFeaturesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShadingRateImageFeaturesNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceShadingRateImageFeaturesNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( shadingRateImage == rhs.shadingRateImage ) + && ( shadingRateCoarseSampleOrder == rhs.shadingRateCoarseSampleOrder ); + } + + bool operator!=( PhysicalDeviceShadingRateImageFeaturesNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV; + + public: + void* pNext = nullptr; + Bool32 shadingRateImage; + Bool32 shadingRateCoarseSampleOrder; + }; + static_assert( sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) == sizeof( VkPhysicalDeviceShadingRateImageFeaturesNV ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceShadingRateImagePropertiesNV + { + operator VkPhysicalDeviceShadingRateImagePropertiesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShadingRateImagePropertiesNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceShadingRateImagePropertiesNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( shadingRateTexelSize == rhs.shadingRateTexelSize ) + && ( shadingRatePaletteSize == rhs.shadingRatePaletteSize ) + && ( shadingRateMaxCoarseSamples == rhs.shadingRateMaxCoarseSamples ); + } + + bool operator!=( PhysicalDeviceShadingRateImagePropertiesNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV; + + public: + void* pNext = nullptr; + Extent2D shadingRateTexelSize; + uint32_t shadingRatePaletteSize; + uint32_t shadingRateMaxCoarseSamples; + }; + static_assert( sizeof( PhysicalDeviceShadingRateImagePropertiesNV ) == sizeof( VkPhysicalDeviceShadingRateImagePropertiesNV ), "struct and wrapper have different size!" ); + + 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 VkPhysicalDeviceSparseImageFormatInfo2 const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSparseImageFormatInfo2 &() + { + 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!" ); + + struct PhysicalDeviceSubgroupProperties + { + operator VkPhysicalDeviceSubgroupProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubgroupProperties &() + { + 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!" ); + + 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 VkPhysicalDeviceSurfaceInfo2KHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSurfaceInfo2KHR &() + { + 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 PhysicalDeviceTransformFeedbackFeaturesEXT + { + PhysicalDeviceTransformFeedbackFeaturesEXT( Bool32 transformFeedback_ = 0, + Bool32 geometryStreams_ = 0 ) + : transformFeedback( transformFeedback_ ) + , geometryStreams( geometryStreams_ ) + {} + + PhysicalDeviceTransformFeedbackFeaturesEXT( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) ); + } + + PhysicalDeviceTransformFeedbackFeaturesEXT& operator=( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) ); + return *this; + } + + PhysicalDeviceTransformFeedbackFeaturesEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceTransformFeedbackFeaturesEXT & setTransformFeedback( Bool32 transformFeedback_ ) + { + transformFeedback = transformFeedback_; + return *this; + } + + PhysicalDeviceTransformFeedbackFeaturesEXT & setGeometryStreams( Bool32 geometryStreams_ ) + { + geometryStreams = geometryStreams_; + return *this; + } + + operator VkPhysicalDeviceTransformFeedbackFeaturesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTransformFeedbackFeaturesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceTransformFeedbackFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( transformFeedback == rhs.transformFeedback ) + && ( geometryStreams == rhs.geometryStreams ); + } + + bool operator!=( PhysicalDeviceTransformFeedbackFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT; + + public: + void* pNext = nullptr; + Bool32 transformFeedback; + Bool32 geometryStreams; + }; + static_assert( sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackFeaturesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceTransformFeedbackPropertiesEXT + { + operator VkPhysicalDeviceTransformFeedbackPropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTransformFeedbackPropertiesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceTransformFeedbackPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( maxTransformFeedbackStreams == rhs.maxTransformFeedbackStreams ) + && ( maxTransformFeedbackBuffers == rhs.maxTransformFeedbackBuffers ) + && ( maxTransformFeedbackBufferSize == rhs.maxTransformFeedbackBufferSize ) + && ( maxTransformFeedbackStreamDataSize == rhs.maxTransformFeedbackStreamDataSize ) + && ( maxTransformFeedbackBufferDataSize == rhs.maxTransformFeedbackBufferDataSize ) + && ( maxTransformFeedbackBufferDataStride == rhs.maxTransformFeedbackBufferDataStride ) + && ( transformFeedbackQueries == rhs.transformFeedbackQueries ) + && ( transformFeedbackStreamsLinesTriangles == rhs.transformFeedbackStreamsLinesTriangles ) + && ( transformFeedbackRasterizationStreamSelect == rhs.transformFeedbackRasterizationStreamSelect ) + && ( transformFeedbackDraw == rhs.transformFeedbackDraw ); + } + + bool operator!=( PhysicalDeviceTransformFeedbackPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT; + + public: + void* pNext = nullptr; + uint32_t maxTransformFeedbackStreams; + uint32_t maxTransformFeedbackBuffers; + DeviceSize maxTransformFeedbackBufferSize; + uint32_t maxTransformFeedbackStreamDataSize; + uint32_t maxTransformFeedbackBufferDataSize; + uint32_t maxTransformFeedbackBufferDataStride; + Bool32 transformFeedbackQueries; + Bool32 transformFeedbackStreamsLinesTriangles; + Bool32 transformFeedbackRasterizationStreamSelect; + Bool32 transformFeedbackDraw; + }; + static_assert( sizeof( PhysicalDeviceTransformFeedbackPropertiesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackPropertiesEXT ), "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 VkPhysicalDeviceVariablePointerFeatures const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVariablePointerFeatures &() + { + 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!" ); + + struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT + { + PhysicalDeviceVertexAttributeDivisorFeaturesEXT( Bool32 vertexAttributeInstanceRateDivisor_ = 0, + Bool32 vertexAttributeInstanceRateZeroDivisor_ = 0 ) + : vertexAttributeInstanceRateDivisor( vertexAttributeInstanceRateDivisor_ ) + , vertexAttributeInstanceRateZeroDivisor( vertexAttributeInstanceRateZeroDivisor_ ) + {} + + PhysicalDeviceVertexAttributeDivisorFeaturesEXT( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) ); + } + + PhysicalDeviceVertexAttributeDivisorFeaturesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) ); + return *this; + } + + PhysicalDeviceVertexAttributeDivisorFeaturesEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceVertexAttributeDivisorFeaturesEXT & setVertexAttributeInstanceRateDivisor( Bool32 vertexAttributeInstanceRateDivisor_ ) + { + vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor_; + return *this; + } + + PhysicalDeviceVertexAttributeDivisorFeaturesEXT & setVertexAttributeInstanceRateZeroDivisor( Bool32 vertexAttributeInstanceRateZeroDivisor_ ) + { + vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor_; + return *this; + } + + operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( vertexAttributeInstanceRateDivisor == rhs.vertexAttributeInstanceRateDivisor ) + && ( vertexAttributeInstanceRateZeroDivisor == rhs.vertexAttributeInstanceRateZeroDivisor ); + } + + bool operator!=( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT; + + public: + void* pNext = nullptr; + Bool32 vertexAttributeInstanceRateDivisor; + Bool32 vertexAttributeInstanceRateZeroDivisor; + }; + static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT + { + operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &() + { + 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!" ); + + struct PhysicalDeviceVulkanMemoryModelFeaturesKHR + { + PhysicalDeviceVulkanMemoryModelFeaturesKHR( Bool32 vulkanMemoryModel_ = 0, + Bool32 vulkanMemoryModelDeviceScope_ = 0, + Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = 0 ) + : vulkanMemoryModel( vulkanMemoryModel_ ) + , vulkanMemoryModelDeviceScope( vulkanMemoryModelDeviceScope_ ) + , vulkanMemoryModelAvailabilityVisibilityChains( vulkanMemoryModelAvailabilityVisibilityChains_ ) + {} + + PhysicalDeviceVulkanMemoryModelFeaturesKHR( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceVulkanMemoryModelFeaturesKHR ) ); + } + + PhysicalDeviceVulkanMemoryModelFeaturesKHR& operator=( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceVulkanMemoryModelFeaturesKHR ) ); + return *this; + } + + PhysicalDeviceVulkanMemoryModelFeaturesKHR & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceVulkanMemoryModelFeaturesKHR & setVulkanMemoryModel( Bool32 vulkanMemoryModel_ ) + { + vulkanMemoryModel = vulkanMemoryModel_; + return *this; + } + + PhysicalDeviceVulkanMemoryModelFeaturesKHR & setVulkanMemoryModelDeviceScope( Bool32 vulkanMemoryModelDeviceScope_ ) + { + vulkanMemoryModelDeviceScope = vulkanMemoryModelDeviceScope_; + return *this; + } + + PhysicalDeviceVulkanMemoryModelFeaturesKHR & setVulkanMemoryModelAvailabilityVisibilityChains( Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ ) + { + vulkanMemoryModelAvailabilityVisibilityChains = vulkanMemoryModelAvailabilityVisibilityChains_; + return *this; + } + + operator VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkanMemoryModelFeaturesKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceVulkanMemoryModelFeaturesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( vulkanMemoryModel == rhs.vulkanMemoryModel ) + && ( vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope ) + && ( vulkanMemoryModelAvailabilityVisibilityChains == rhs.vulkanMemoryModelAvailabilityVisibilityChains ); + } + + bool operator!=( PhysicalDeviceVulkanMemoryModelFeaturesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR; + + public: + void* pNext = nullptr; + Bool32 vulkanMemoryModel; + Bool32 vulkanMemoryModelDeviceScope; + Bool32 vulkanMemoryModelAvailabilityVisibilityChains; + }; + static_assert( sizeof( PhysicalDeviceVulkanMemoryModelFeaturesKHR ) == sizeof( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR ), "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 VkPipelineCacheCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCacheCreateInfo &() + { + 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 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 VkPipelineColorBlendAdvancedStateCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineColorBlendAdvancedStateCreateInfoEXT &() + { + 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!" ); + + 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 VkPipelineCoverageModulationStateCreateInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCoverageModulationStateCreateInfoNV &() + { + 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!" ); + + 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 VkPipelineCoverageToColorStateCreateInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCoverageToColorStateCreateInfoNV &() + { + 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 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 VkPipelineDiscardRectangleStateCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineDiscardRectangleStateCreateInfoEXT &() + { + 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!" ); + + 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 VkPushConstantRange const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPushConstantRange &() + { + 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 VkPipelineLayoutCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineLayoutCreateInfo &() + { + 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 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 VkPipelineRasterizationConservativeStateCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationConservativeStateCreateInfoEXT &() + { + 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!" ); + + struct PipelineRasterizationDepthClipStateCreateInfoEXT + { + PipelineRasterizationDepthClipStateCreateInfoEXT( PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ = PipelineRasterizationDepthClipStateCreateFlagsEXT(), + Bool32 depthClipEnable_ = 0 ) + : flags( flags_ ) + , depthClipEnable( depthClipEnable_ ) + {} + + PipelineRasterizationDepthClipStateCreateInfoEXT( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) ); + } + + PipelineRasterizationDepthClipStateCreateInfoEXT& operator=( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) ); + return *this; + } + + PipelineRasterizationDepthClipStateCreateInfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineRasterizationDepthClipStateCreateInfoEXT & setFlags( PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ ) + { + flags = flags_; + return *this; + } + + PipelineRasterizationDepthClipStateCreateInfoEXT & setDepthClipEnable( Bool32 depthClipEnable_ ) + { + depthClipEnable = depthClipEnable_; + return *this; + } + + operator VkPipelineRasterizationDepthClipStateCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationDepthClipStateCreateInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PipelineRasterizationDepthClipStateCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( depthClipEnable == rhs.depthClipEnable ); + } + + bool operator!=( PipelineRasterizationDepthClipStateCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT; + + public: + const void* pNext = nullptr; + PipelineRasterizationDepthClipStateCreateFlagsEXT flags; + Bool32 depthClipEnable; + }; + static_assert( sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationDepthClipStateCreateInfoEXT ), "struct and wrapper have different size!" ); + + 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 VkPipelineRasterizationStateRasterizationOrderAMD const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationStateRasterizationOrderAMD &() + { + 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!" ); + + struct PipelineRasterizationStateStreamCreateInfoEXT + { + PipelineRasterizationStateStreamCreateInfoEXT( PipelineRasterizationStateStreamCreateFlagsEXT flags_ = PipelineRasterizationStateStreamCreateFlagsEXT(), + uint32_t rasterizationStream_ = 0 ) + : flags( flags_ ) + , rasterizationStream( rasterizationStream_ ) + {} + + PipelineRasterizationStateStreamCreateInfoEXT( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) ); + } + + PipelineRasterizationStateStreamCreateInfoEXT& operator=( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) ); + return *this; + } + + PipelineRasterizationStateStreamCreateInfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineRasterizationStateStreamCreateInfoEXT & setFlags( PipelineRasterizationStateStreamCreateFlagsEXT flags_ ) + { + flags = flags_; + return *this; + } + + PipelineRasterizationStateStreamCreateInfoEXT & setRasterizationStream( uint32_t rasterizationStream_ ) + { + rasterizationStream = rasterizationStream_; + return *this; + } + + operator VkPipelineRasterizationStateStreamCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationStateStreamCreateInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PipelineRasterizationStateStreamCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( rasterizationStream == rhs.rasterizationStream ); + } + + bool operator!=( PipelineRasterizationStateStreamCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT; + + public: + const void* pNext = nullptr; + PipelineRasterizationStateStreamCreateFlagsEXT flags; + uint32_t rasterizationStream; + }; + static_assert( sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) == sizeof( VkPipelineRasterizationStateStreamCreateInfoEXT ), "struct and wrapper have different size!" ); + + struct PipelineRepresentativeFragmentTestStateCreateInfoNV + { + PipelineRepresentativeFragmentTestStateCreateInfoNV( Bool32 representativeFragmentTestEnable_ = 0 ) + : representativeFragmentTestEnable( representativeFragmentTestEnable_ ) + {} + + PipelineRepresentativeFragmentTestStateCreateInfoNV( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) ); + } + + PipelineRepresentativeFragmentTestStateCreateInfoNV& operator=( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) ); + return *this; + } + + PipelineRepresentativeFragmentTestStateCreateInfoNV & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineRepresentativeFragmentTestStateCreateInfoNV & setRepresentativeFragmentTestEnable( Bool32 representativeFragmentTestEnable_ ) + { + representativeFragmentTestEnable = representativeFragmentTestEnable_; + return *this; + } + + operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PipelineRepresentativeFragmentTestStateCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( representativeFragmentTestEnable == rhs.representativeFragmentTestEnable ); + } + + bool operator!=( PipelineRepresentativeFragmentTestStateCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV; + + public: + const void* pNext = nullptr; + Bool32 representativeFragmentTestEnable; + }; + static_assert( sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) == sizeof( VkPipelineRepresentativeFragmentTestStateCreateInfoNV ), "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 VkPipelineSampleLocationsStateCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineSampleLocationsStateCreateInfoEXT &() + { + 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 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 VkPipelineTessellationDomainOriginStateCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineTessellationDomainOriginStateCreateInfo &() + { + 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!" ); + + 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 VkVertexInputBindingDivisorDescriptionEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkVertexInputBindingDivisorDescriptionEXT &() + { + 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!" ); + + 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 VkPipelineVertexInputDivisorStateCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineVertexInputDivisorStateCreateInfoEXT &() + { + 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 PipelineViewportCoarseSampleOrderStateCreateInfoNV + { + PipelineViewportCoarseSampleOrderStateCreateInfoNV( CoarseSampleOrderTypeNV sampleOrderType_ = CoarseSampleOrderTypeNV::eDefault, + uint32_t customSampleOrderCount_ = 0, + const CoarseSampleOrderCustomNV* pCustomSampleOrders_ = nullptr ) + : sampleOrderType( sampleOrderType_ ) + , customSampleOrderCount( customSampleOrderCount_ ) + , pCustomSampleOrders( pCustomSampleOrders_ ) + {} + + PipelineViewportCoarseSampleOrderStateCreateInfoNV( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) ); + } + + PipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) ); + return *this; + } + + PipelineViewportCoarseSampleOrderStateCreateInfoNV & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineViewportCoarseSampleOrderStateCreateInfoNV & setSampleOrderType( CoarseSampleOrderTypeNV sampleOrderType_ ) + { + sampleOrderType = sampleOrderType_; + return *this; + } + + PipelineViewportCoarseSampleOrderStateCreateInfoNV & setCustomSampleOrderCount( uint32_t customSampleOrderCount_ ) + { + customSampleOrderCount = customSampleOrderCount_; + return *this; + } + + PipelineViewportCoarseSampleOrderStateCreateInfoNV & setPCustomSampleOrders( const CoarseSampleOrderCustomNV* pCustomSampleOrders_ ) + { + pCustomSampleOrders = pCustomSampleOrders_; + return *this; + } + + operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PipelineViewportCoarseSampleOrderStateCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( sampleOrderType == rhs.sampleOrderType ) + && ( customSampleOrderCount == rhs.customSampleOrderCount ) + && ( pCustomSampleOrders == rhs.pCustomSampleOrders ); + } + + bool operator!=( PipelineViewportCoarseSampleOrderStateCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV; + + public: + const void* pNext = nullptr; + CoarseSampleOrderTypeNV sampleOrderType; + uint32_t customSampleOrderCount; + const CoarseSampleOrderCustomNV* pCustomSampleOrders; + }; + static_assert( sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) == sizeof( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV ), "struct and wrapper have different size!" ); + + struct PipelineViewportExclusiveScissorStateCreateInfoNV + { + PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = 0, + const Rect2D* pExclusiveScissors_ = nullptr ) + : exclusiveScissorCount( exclusiveScissorCount_ ) + , pExclusiveScissors( pExclusiveScissors_ ) + {} + + PipelineViewportExclusiveScissorStateCreateInfoNV( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) ); + } + + PipelineViewportExclusiveScissorStateCreateInfoNV& operator=( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) ); + return *this; + } + + PipelineViewportExclusiveScissorStateCreateInfoNV & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineViewportExclusiveScissorStateCreateInfoNV & setExclusiveScissorCount( uint32_t exclusiveScissorCount_ ) + { + exclusiveScissorCount = exclusiveScissorCount_; + return *this; + } + + PipelineViewportExclusiveScissorStateCreateInfoNV & setPExclusiveScissors( const Rect2D* pExclusiveScissors_ ) + { + pExclusiveScissors = pExclusiveScissors_; + return *this; + } + + operator VkPipelineViewportExclusiveScissorStateCreateInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportExclusiveScissorStateCreateInfoNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PipelineViewportExclusiveScissorStateCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( exclusiveScissorCount == rhs.exclusiveScissorCount ) + && ( pExclusiveScissors == rhs.pExclusiveScissors ); + } + + bool operator!=( PipelineViewportExclusiveScissorStateCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV; + + public: + const void* pNext = nullptr; + uint32_t exclusiveScissorCount; + const Rect2D* pExclusiveScissors; + }; + static_assert( sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) == sizeof( VkPipelineViewportExclusiveScissorStateCreateInfoNV ), "struct and wrapper have different size!" ); + + struct ShadingRatePaletteNV + { + ShadingRatePaletteNV( uint32_t shadingRatePaletteEntryCount_ = 0, + const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ = nullptr ) + : shadingRatePaletteEntryCount( shadingRatePaletteEntryCount_ ) + , pShadingRatePaletteEntries( pShadingRatePaletteEntries_ ) + {} + + ShadingRatePaletteNV( VkShadingRatePaletteNV const & rhs ) + { + memcpy( this, &rhs, sizeof( ShadingRatePaletteNV ) ); + } + + ShadingRatePaletteNV& operator=( VkShadingRatePaletteNV const & rhs ) + { + memcpy( this, &rhs, sizeof( ShadingRatePaletteNV ) ); + return *this; + } + + ShadingRatePaletteNV & setShadingRatePaletteEntryCount( uint32_t shadingRatePaletteEntryCount_ ) + { + shadingRatePaletteEntryCount = shadingRatePaletteEntryCount_; + return *this; + } + + ShadingRatePaletteNV & setPShadingRatePaletteEntries( const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ ) + { + pShadingRatePaletteEntries = pShadingRatePaletteEntries_; + return *this; + } + + operator VkShadingRatePaletteNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkShadingRatePaletteNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( ShadingRatePaletteNV const& rhs ) const + { + return ( shadingRatePaletteEntryCount == rhs.shadingRatePaletteEntryCount ) + && ( pShadingRatePaletteEntries == rhs.pShadingRatePaletteEntries ); + } + + bool operator!=( ShadingRatePaletteNV const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t shadingRatePaletteEntryCount; + const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries; + }; + static_assert( sizeof( ShadingRatePaletteNV ) == sizeof( VkShadingRatePaletteNV ), "struct and wrapper have different size!" ); + + struct PipelineViewportShadingRateImageStateCreateInfoNV + { + PipelineViewportShadingRateImageStateCreateInfoNV( Bool32 shadingRateImageEnable_ = 0, + uint32_t viewportCount_ = 0, + const ShadingRatePaletteNV* pShadingRatePalettes_ = nullptr ) + : shadingRateImageEnable( shadingRateImageEnable_ ) + , viewportCount( viewportCount_ ) + , pShadingRatePalettes( pShadingRatePalettes_ ) + {} + + PipelineViewportShadingRateImageStateCreateInfoNV( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) ); + } + + PipelineViewportShadingRateImageStateCreateInfoNV& operator=( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) ); + return *this; + } + + PipelineViewportShadingRateImageStateCreateInfoNV & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineViewportShadingRateImageStateCreateInfoNV & setShadingRateImageEnable( Bool32 shadingRateImageEnable_ ) + { + shadingRateImageEnable = shadingRateImageEnable_; + return *this; + } + + PipelineViewportShadingRateImageStateCreateInfoNV & setViewportCount( uint32_t viewportCount_ ) + { + viewportCount = viewportCount_; + return *this; + } + + PipelineViewportShadingRateImageStateCreateInfoNV & setPShadingRatePalettes( const ShadingRatePaletteNV* pShadingRatePalettes_ ) + { + pShadingRatePalettes = pShadingRatePalettes_; + return *this; + } + + operator VkPipelineViewportShadingRateImageStateCreateInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportShadingRateImageStateCreateInfoNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PipelineViewportShadingRateImageStateCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( shadingRateImageEnable == rhs.shadingRateImageEnable ) + && ( viewportCount == rhs.viewportCount ) + && ( pShadingRatePalettes == rhs.pShadingRatePalettes ); + } + + bool operator!=( PipelineViewportShadingRateImageStateCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV; + + public: + const void* pNext = nullptr; + Bool32 shadingRateImageEnable; + uint32_t viewportCount; + const ShadingRatePaletteNV* pShadingRatePalettes; + }; + static_assert( sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) == sizeof( VkPipelineViewportShadingRateImageStateCreateInfoNV ), "struct and wrapper have different size!" ); + + 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 VkViewportSwizzleNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkViewportSwizzleNV &() + { + 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 VkPipelineViewportSwizzleStateCreateInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportSwizzleStateCreateInfoNV &() + { + 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!" ); + + 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 VkViewportWScalingNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkViewportWScalingNV &() + { + 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 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 VkPipelineViewportWScalingStateCreateInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportWScalingStateCreateInfoNV &() + { + 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 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 VkPresentInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPresentInfoKHR &() + { + 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!" ); + + 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 VkRectLayerKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkRectLayerKHR &() + { + 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 VkPresentRegionKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPresentRegionKHR &() + { + 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 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 VkPresentRegionsKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPresentRegionsKHR &() + { + 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 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 VkPresentTimeGOOGLE const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPresentTimeGOOGLE &() + { + 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 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 VkPresentTimesInfoGOOGLE const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPresentTimesInfoGOOGLE &() + { + 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!" ); + + 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 VkProtectedSubmitInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkProtectedSubmitInfo &() + { + 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 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 VkQueryPoolCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkQueryPoolCreateInfo &() + { + 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!" ); + + struct QueueFamilyCheckpointPropertiesNV + { + operator VkQueueFamilyCheckpointPropertiesNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyCheckpointPropertiesNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( QueueFamilyCheckpointPropertiesNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask ); + } + + bool operator!=( QueueFamilyCheckpointPropertiesNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV; + + public: + void* pNext = nullptr; + PipelineStageFlags checkpointExecutionStageMask; + }; + static_assert( sizeof( QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), "struct and wrapper have different size!" ); + + struct QueueFamilyProperties + { + operator VkQueueFamilyProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyProperties &() + { + 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 VkQueueFamilyProperties2 const&() const + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyProperties2 &() + { + 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!" ); + + struct RayTracingShaderGroupCreateInfoNV + { + RayTracingShaderGroupCreateInfoNV( RayTracingShaderGroupTypeNV type_ = RayTracingShaderGroupTypeNV::eGeneral, + uint32_t generalShader_ = 0, + uint32_t closestHitShader_ = 0, + uint32_t anyHitShader_ = 0, + uint32_t intersectionShader_ = 0 ) + : type( type_ ) + , generalShader( generalShader_ ) + , closestHitShader( closestHitShader_ ) + , anyHitShader( anyHitShader_ ) + , intersectionShader( intersectionShader_ ) + {} + + RayTracingShaderGroupCreateInfoNV( VkRayTracingShaderGroupCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( RayTracingShaderGroupCreateInfoNV ) ); + } + + RayTracingShaderGroupCreateInfoNV& operator=( VkRayTracingShaderGroupCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( RayTracingShaderGroupCreateInfoNV ) ); + return *this; + } + + RayTracingShaderGroupCreateInfoNV & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + RayTracingShaderGroupCreateInfoNV & setType( RayTracingShaderGroupTypeNV type_ ) + { + type = type_; + return *this; + } + + RayTracingShaderGroupCreateInfoNV & setGeneralShader( uint32_t generalShader_ ) + { + generalShader = generalShader_; + return *this; + } + + RayTracingShaderGroupCreateInfoNV & setClosestHitShader( uint32_t closestHitShader_ ) + { + closestHitShader = closestHitShader_; + return *this; + } + + RayTracingShaderGroupCreateInfoNV & setAnyHitShader( uint32_t anyHitShader_ ) + { + anyHitShader = anyHitShader_; + return *this; + } + + RayTracingShaderGroupCreateInfoNV & setIntersectionShader( uint32_t intersectionShader_ ) + { + intersectionShader = intersectionShader_; + return *this; + } + + operator VkRayTracingShaderGroupCreateInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkRayTracingShaderGroupCreateInfoNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( RayTracingShaderGroupCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( type == rhs.type ) + && ( generalShader == rhs.generalShader ) + && ( closestHitShader == rhs.closestHitShader ) + && ( anyHitShader == rhs.anyHitShader ) + && ( intersectionShader == rhs.intersectionShader ); + } + + bool operator!=( RayTracingShaderGroupCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoNV; + + public: + const void* pNext = nullptr; + RayTracingShaderGroupTypeNV type; + uint32_t generalShader; + uint32_t closestHitShader; + uint32_t anyHitShader; + uint32_t intersectionShader; + }; + static_assert( sizeof( RayTracingShaderGroupCreateInfoNV ) == sizeof( VkRayTracingShaderGroupCreateInfoNV ), "struct and wrapper have different size!" ); + + struct RayTracingPipelineCreateInfoNV + { + RayTracingPipelineCreateInfoNV( PipelineCreateFlags flags_ = PipelineCreateFlags(), + uint32_t stageCount_ = 0, + const PipelineShaderStageCreateInfo* pStages_ = nullptr, + uint32_t groupCount_ = 0, + const RayTracingShaderGroupCreateInfoNV* pGroups_ = nullptr, + uint32_t maxRecursionDepth_ = 0, + PipelineLayout layout_ = PipelineLayout(), + Pipeline basePipelineHandle_ = Pipeline(), + int32_t basePipelineIndex_ = 0 ) + : flags( flags_ ) + , stageCount( stageCount_ ) + , pStages( pStages_ ) + , groupCount( groupCount_ ) + , pGroups( pGroups_ ) + , maxRecursionDepth( maxRecursionDepth_ ) + , layout( layout_ ) + , basePipelineHandle( basePipelineHandle_ ) + , basePipelineIndex( basePipelineIndex_ ) + {} + + RayTracingPipelineCreateInfoNV( VkRayTracingPipelineCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( RayTracingPipelineCreateInfoNV ) ); + } + + RayTracingPipelineCreateInfoNV& operator=( VkRayTracingPipelineCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( RayTracingPipelineCreateInfoNV ) ); + return *this; + } + + RayTracingPipelineCreateInfoNV & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + RayTracingPipelineCreateInfoNV & setFlags( PipelineCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + RayTracingPipelineCreateInfoNV & setStageCount( uint32_t stageCount_ ) + { + stageCount = stageCount_; + return *this; + } + + RayTracingPipelineCreateInfoNV & setPStages( const PipelineShaderStageCreateInfo* pStages_ ) + { + pStages = pStages_; + return *this; + } + + RayTracingPipelineCreateInfoNV & setGroupCount( uint32_t groupCount_ ) + { + groupCount = groupCount_; + return *this; + } + + RayTracingPipelineCreateInfoNV & setPGroups( const RayTracingShaderGroupCreateInfoNV* pGroups_ ) + { + pGroups = pGroups_; + return *this; + } + + RayTracingPipelineCreateInfoNV & setMaxRecursionDepth( uint32_t maxRecursionDepth_ ) + { + maxRecursionDepth = maxRecursionDepth_; + return *this; + } + + RayTracingPipelineCreateInfoNV & setLayout( PipelineLayout layout_ ) + { + layout = layout_; + return *this; + } + + RayTracingPipelineCreateInfoNV & setBasePipelineHandle( Pipeline basePipelineHandle_ ) + { + basePipelineHandle = basePipelineHandle_; + return *this; + } + + RayTracingPipelineCreateInfoNV & setBasePipelineIndex( int32_t basePipelineIndex_ ) + { + basePipelineIndex = basePipelineIndex_; + return *this; + } + + operator VkRayTracingPipelineCreateInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkRayTracingPipelineCreateInfoNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( RayTracingPipelineCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( stageCount == rhs.stageCount ) + && ( pStages == rhs.pStages ) + && ( groupCount == rhs.groupCount ) + && ( pGroups == rhs.pGroups ) + && ( maxRecursionDepth == rhs.maxRecursionDepth ) + && ( layout == rhs.layout ) + && ( basePipelineHandle == rhs.basePipelineHandle ) + && ( basePipelineIndex == rhs.basePipelineIndex ); + } + + bool operator!=( RayTracingPipelineCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eRayTracingPipelineCreateInfoNV; + + public: + const void* pNext = nullptr; + PipelineCreateFlags flags; + uint32_t stageCount; + const PipelineShaderStageCreateInfo* pStages; + uint32_t groupCount; + const RayTracingShaderGroupCreateInfoNV* pGroups; + uint32_t maxRecursionDepth; + PipelineLayout layout; + Pipeline basePipelineHandle; + int32_t basePipelineIndex; + }; + static_assert( sizeof( RayTracingPipelineCreateInfoNV ) == sizeof( VkRayTracingPipelineCreateInfoNV ), "struct and wrapper have different size!" ); + + struct RefreshCycleDurationGOOGLE + { + operator VkRefreshCycleDurationGOOGLE const&() const + { + return *reinterpret_cast( this ); + } + + operator VkRefreshCycleDurationGOOGLE &() + { + 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 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 VkRenderPassBeginInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassBeginInfo &() + { + 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 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 VkSubpassDescription const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSubpassDescription &() + { + 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 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 VkSubpassDependency const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSubpassDependency &() + { + 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!" ); + + 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 VkRenderPassCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassCreateInfo &() + { + 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!" ); + + struct SubpassDescription2KHR + { + SubpassDescription2KHR( SubpassDescriptionFlags flags_ = SubpassDescriptionFlags(), + PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, + uint32_t viewMask_ = 0, + uint32_t inputAttachmentCount_ = 0, + const AttachmentReference2KHR* pInputAttachments_ = nullptr, + uint32_t colorAttachmentCount_ = 0, + const AttachmentReference2KHR* pColorAttachments_ = nullptr, + const AttachmentReference2KHR* pResolveAttachments_ = nullptr, + const AttachmentReference2KHR* pDepthStencilAttachment_ = nullptr, + uint32_t preserveAttachmentCount_ = 0, + const uint32_t* pPreserveAttachments_ = nullptr ) + : flags( flags_ ) + , pipelineBindPoint( pipelineBindPoint_ ) + , viewMask( viewMask_ ) + , inputAttachmentCount( inputAttachmentCount_ ) + , pInputAttachments( pInputAttachments_ ) + , colorAttachmentCount( colorAttachmentCount_ ) + , pColorAttachments( pColorAttachments_ ) + , pResolveAttachments( pResolveAttachments_ ) + , pDepthStencilAttachment( pDepthStencilAttachment_ ) + , preserveAttachmentCount( preserveAttachmentCount_ ) + , pPreserveAttachments( pPreserveAttachments_ ) + {} + + SubpassDescription2KHR( VkSubpassDescription2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SubpassDescription2KHR ) ); + } + + SubpassDescription2KHR& operator=( VkSubpassDescription2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SubpassDescription2KHR ) ); + return *this; + } + + SubpassDescription2KHR & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SubpassDescription2KHR & setFlags( SubpassDescriptionFlags flags_ ) + { + flags = flags_; + return *this; + } + + SubpassDescription2KHR & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) + { + pipelineBindPoint = pipelineBindPoint_; + return *this; + } + + SubpassDescription2KHR & setViewMask( uint32_t viewMask_ ) + { + viewMask = viewMask_; + return *this; + } + + SubpassDescription2KHR & setInputAttachmentCount( uint32_t inputAttachmentCount_ ) + { + inputAttachmentCount = inputAttachmentCount_; + return *this; + } + + SubpassDescription2KHR & setPInputAttachments( const AttachmentReference2KHR* pInputAttachments_ ) + { + pInputAttachments = pInputAttachments_; + return *this; + } + + SubpassDescription2KHR & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) + { + colorAttachmentCount = colorAttachmentCount_; + return *this; + } + + SubpassDescription2KHR & setPColorAttachments( const AttachmentReference2KHR* pColorAttachments_ ) + { + pColorAttachments = pColorAttachments_; + return *this; + } + + SubpassDescription2KHR & setPResolveAttachments( const AttachmentReference2KHR* pResolveAttachments_ ) + { + pResolveAttachments = pResolveAttachments_; + return *this; + } + + SubpassDescription2KHR & setPDepthStencilAttachment( const AttachmentReference2KHR* pDepthStencilAttachment_ ) + { + pDepthStencilAttachment = pDepthStencilAttachment_; + return *this; + } + + SubpassDescription2KHR & setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ ) + { + preserveAttachmentCount = preserveAttachmentCount_; + return *this; + } + + SubpassDescription2KHR & setPPreserveAttachments( const uint32_t* pPreserveAttachments_ ) + { + pPreserveAttachments = pPreserveAttachments_; + return *this; + } + + operator VkSubpassDescription2KHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSubpassDescription2KHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( SubpassDescription2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( pipelineBindPoint == rhs.pipelineBindPoint ) + && ( viewMask == rhs.viewMask ) + && ( 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!=( SubpassDescription2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSubpassDescription2KHR; + + public: + const void* pNext = nullptr; + SubpassDescriptionFlags flags; + PipelineBindPoint pipelineBindPoint; + uint32_t viewMask; + uint32_t inputAttachmentCount; + const AttachmentReference2KHR* pInputAttachments; + uint32_t colorAttachmentCount; + const AttachmentReference2KHR* pColorAttachments; + const AttachmentReference2KHR* pResolveAttachments; + const AttachmentReference2KHR* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; + }; + static_assert( sizeof( SubpassDescription2KHR ) == sizeof( VkSubpassDescription2KHR ), "struct and wrapper have different size!" ); + + struct SubpassDependency2KHR + { + SubpassDependency2KHR( uint32_t srcSubpass_ = 0, + uint32_t dstSubpass_ = 0, + PipelineStageFlags srcStageMask_ = PipelineStageFlags(), + PipelineStageFlags dstStageMask_ = PipelineStageFlags(), + AccessFlags srcAccessMask_ = AccessFlags(), + AccessFlags dstAccessMask_ = AccessFlags(), + DependencyFlags dependencyFlags_ = DependencyFlags(), + int32_t viewOffset_ = 0 ) + : srcSubpass( srcSubpass_ ) + , dstSubpass( dstSubpass_ ) + , srcStageMask( srcStageMask_ ) + , dstStageMask( dstStageMask_ ) + , srcAccessMask( srcAccessMask_ ) + , dstAccessMask( dstAccessMask_ ) + , dependencyFlags( dependencyFlags_ ) + , viewOffset( viewOffset_ ) + {} + + SubpassDependency2KHR( VkSubpassDependency2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SubpassDependency2KHR ) ); + } + + SubpassDependency2KHR& operator=( VkSubpassDependency2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SubpassDependency2KHR ) ); + return *this; + } + + SubpassDependency2KHR & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SubpassDependency2KHR & setSrcSubpass( uint32_t srcSubpass_ ) + { + srcSubpass = srcSubpass_; + return *this; + } + + SubpassDependency2KHR & setDstSubpass( uint32_t dstSubpass_ ) + { + dstSubpass = dstSubpass_; + return *this; + } + + SubpassDependency2KHR & setSrcStageMask( PipelineStageFlags srcStageMask_ ) + { + srcStageMask = srcStageMask_; + return *this; + } + + SubpassDependency2KHR & setDstStageMask( PipelineStageFlags dstStageMask_ ) + { + dstStageMask = dstStageMask_; + return *this; + } + + SubpassDependency2KHR & setSrcAccessMask( AccessFlags srcAccessMask_ ) + { + srcAccessMask = srcAccessMask_; + return *this; + } + + SubpassDependency2KHR & setDstAccessMask( AccessFlags dstAccessMask_ ) + { + dstAccessMask = dstAccessMask_; + return *this; + } + + SubpassDependency2KHR & setDependencyFlags( DependencyFlags dependencyFlags_ ) + { + dependencyFlags = dependencyFlags_; + return *this; + } + + SubpassDependency2KHR & setViewOffset( int32_t viewOffset_ ) + { + viewOffset = viewOffset_; + return *this; + } + + operator VkSubpassDependency2KHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSubpassDependency2KHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( SubpassDependency2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( srcSubpass == rhs.srcSubpass ) + && ( dstSubpass == rhs.dstSubpass ) + && ( srcStageMask == rhs.srcStageMask ) + && ( dstStageMask == rhs.dstStageMask ) + && ( srcAccessMask == rhs.srcAccessMask ) + && ( dstAccessMask == rhs.dstAccessMask ) + && ( dependencyFlags == rhs.dependencyFlags ) + && ( viewOffset == rhs.viewOffset ); + } + + bool operator!=( SubpassDependency2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSubpassDependency2KHR; + + public: + const void* pNext = nullptr; + uint32_t srcSubpass; + uint32_t dstSubpass; + PipelineStageFlags srcStageMask; + PipelineStageFlags dstStageMask; + AccessFlags srcAccessMask; + AccessFlags dstAccessMask; + DependencyFlags dependencyFlags; + int32_t viewOffset; + }; + static_assert( sizeof( SubpassDependency2KHR ) == sizeof( VkSubpassDependency2KHR ), "struct and wrapper have different size!" ); + + struct RenderPassCreateInfo2KHR + { + RenderPassCreateInfo2KHR( RenderPassCreateFlags flags_ = RenderPassCreateFlags(), + uint32_t attachmentCount_ = 0, + const AttachmentDescription2KHR* pAttachments_ = nullptr, + uint32_t subpassCount_ = 0, + const SubpassDescription2KHR* pSubpasses_ = nullptr, + uint32_t dependencyCount_ = 0, + const SubpassDependency2KHR* pDependencies_ = nullptr, + uint32_t correlatedViewMaskCount_ = 0, + const uint32_t* pCorrelatedViewMasks_ = nullptr ) + : flags( flags_ ) + , attachmentCount( attachmentCount_ ) + , pAttachments( pAttachments_ ) + , subpassCount( subpassCount_ ) + , pSubpasses( pSubpasses_ ) + , dependencyCount( dependencyCount_ ) + , pDependencies( pDependencies_ ) + , correlatedViewMaskCount( correlatedViewMaskCount_ ) + , pCorrelatedViewMasks( pCorrelatedViewMasks_ ) + {} + + RenderPassCreateInfo2KHR( VkRenderPassCreateInfo2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( RenderPassCreateInfo2KHR ) ); + } + + RenderPassCreateInfo2KHR& operator=( VkRenderPassCreateInfo2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( RenderPassCreateInfo2KHR ) ); + return *this; + } + + RenderPassCreateInfo2KHR & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + RenderPassCreateInfo2KHR & setFlags( RenderPassCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + RenderPassCreateInfo2KHR & setAttachmentCount( uint32_t attachmentCount_ ) + { + attachmentCount = attachmentCount_; + return *this; + } + + RenderPassCreateInfo2KHR & setPAttachments( const AttachmentDescription2KHR* pAttachments_ ) + { + pAttachments = pAttachments_; + return *this; + } + + RenderPassCreateInfo2KHR & setSubpassCount( uint32_t subpassCount_ ) + { + subpassCount = subpassCount_; + return *this; + } + + RenderPassCreateInfo2KHR & setPSubpasses( const SubpassDescription2KHR* pSubpasses_ ) + { + pSubpasses = pSubpasses_; + return *this; + } + + RenderPassCreateInfo2KHR & setDependencyCount( uint32_t dependencyCount_ ) + { + dependencyCount = dependencyCount_; + return *this; + } + + RenderPassCreateInfo2KHR & setPDependencies( const SubpassDependency2KHR* pDependencies_ ) + { + pDependencies = pDependencies_; + return *this; + } + + RenderPassCreateInfo2KHR & setCorrelatedViewMaskCount( uint32_t correlatedViewMaskCount_ ) + { + correlatedViewMaskCount = correlatedViewMaskCount_; + return *this; + } + + RenderPassCreateInfo2KHR & setPCorrelatedViewMasks( const uint32_t* pCorrelatedViewMasks_ ) + { + pCorrelatedViewMasks = pCorrelatedViewMasks_; + return *this; + } + + operator VkRenderPassCreateInfo2KHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassCreateInfo2KHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( RenderPassCreateInfo2KHR 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 ) + && ( correlatedViewMaskCount == rhs.correlatedViewMaskCount ) + && ( pCorrelatedViewMasks == rhs.pCorrelatedViewMasks ); + } + + bool operator!=( RenderPassCreateInfo2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eRenderPassCreateInfo2KHR; + + public: + const void* pNext = nullptr; + RenderPassCreateFlags flags; + uint32_t attachmentCount; + const AttachmentDescription2KHR* pAttachments; + uint32_t subpassCount; + const SubpassDescription2KHR* pSubpasses; + uint32_t dependencyCount; + const SubpassDependency2KHR* pDependencies; + uint32_t correlatedViewMaskCount; + const uint32_t* pCorrelatedViewMasks; + }; + static_assert( sizeof( RenderPassCreateInfo2KHR ) == sizeof( VkRenderPassCreateInfo2KHR ), "struct and wrapper have different size!" ); + + struct RenderPassFragmentDensityMapCreateInfoEXT + { + RenderPassFragmentDensityMapCreateInfoEXT( AttachmentReference fragmentDensityMapAttachment_ = AttachmentReference() ) + : fragmentDensityMapAttachment( fragmentDensityMapAttachment_ ) + {} + + RenderPassFragmentDensityMapCreateInfoEXT( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) ); + } + + RenderPassFragmentDensityMapCreateInfoEXT& operator=( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) ); + return *this; + } + + RenderPassFragmentDensityMapCreateInfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + RenderPassFragmentDensityMapCreateInfoEXT & setFragmentDensityMapAttachment( AttachmentReference fragmentDensityMapAttachment_ ) + { + fragmentDensityMapAttachment = fragmentDensityMapAttachment_; + return *this; + } + + operator VkRenderPassFragmentDensityMapCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassFragmentDensityMapCreateInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( RenderPassFragmentDensityMapCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( fragmentDensityMapAttachment == rhs.fragmentDensityMapAttachment ); + } + + bool operator!=( RenderPassFragmentDensityMapCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT; + + public: + const void* pNext = nullptr; + AttachmentReference fragmentDensityMapAttachment; + }; + static_assert( sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) == sizeof( VkRenderPassFragmentDensityMapCreateInfoEXT ), "struct and wrapper have different size!" ); + + 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 VkRenderPassInputAttachmentAspectCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassInputAttachmentAspectCreateInfo &() + { + 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!" ); + + 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 VkRenderPassMultiviewCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassMultiviewCreateInfo &() + { + 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!" ); + + 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 VkSubpassSampleLocationsEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSubpassSampleLocationsEXT &() + { + 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 VkRenderPassSampleLocationsBeginInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassSampleLocationsBeginInfoEXT &() + { + 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 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 VkSamplerCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSamplerCreateInfo &() + { + 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 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 VkSamplerReductionModeCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSamplerReductionModeCreateInfoEXT &() + { + 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!" ); + + 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 VkSamplerYcbcrConversionCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSamplerYcbcrConversionCreateInfo &() + { + 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!" ); + + struct SamplerYcbcrConversionImageFormatProperties + { + operator VkSamplerYcbcrConversionImageFormatProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSamplerYcbcrConversionImageFormatProperties &() + { + 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!" ); + + 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 VkSamplerYcbcrConversionInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSamplerYcbcrConversionInfo &() + { + 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!" ); + + 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 VkSemaphoreCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreCreateInfo &() + { + 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 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 VkSemaphoreGetFdInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreGetFdInfoKHR &() + { + 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!" ); + +#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 VkSemaphoreGetWin32HandleInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreGetWin32HandleInfoKHR &() + { + 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 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 VkShaderModuleCreateInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkShaderModuleCreateInfo &() + { + 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 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 VkShaderModuleValidationCacheCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkShaderModuleValidationCacheCreateInfoEXT &() + { + 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 ShaderResourceUsageAMD + { + operator VkShaderResourceUsageAMD const&() const + { + return *reinterpret_cast( this ); + } + + operator VkShaderResourceUsageAMD &() + { + 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 ShaderStatisticsInfoAMD + { + operator VkShaderStatisticsInfoAMD const&() const + { + return *reinterpret_cast( this ); + } + + operator VkShaderStatisticsInfoAMD &() + { + 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!" ); + + struct SharedPresentSurfaceCapabilitiesKHR + { + operator VkSharedPresentSurfaceCapabilitiesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSharedPresentSurfaceCapabilitiesKHR &() + { + 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 SparseImageFormatProperties + { + operator VkSparseImageFormatProperties const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageFormatProperties &() + { + 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 SparseImageFormatProperties2 + { + operator VkSparseImageFormatProperties2 const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageFormatProperties2 &() + { + 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!" ); + + struct SparseImageMemoryRequirements + { + operator VkSparseImageMemoryRequirements const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageMemoryRequirements &() + { + 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 SparseImageMemoryRequirements2 + { + operator VkSparseImageMemoryRequirements2 const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageMemoryRequirements2 &() + { + 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!" ); + + 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 VkSubmitInfo const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSubmitInfo &() + { + 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!" ); + + struct SubpassBeginInfoKHR + { + SubpassBeginInfoKHR( SubpassContents contents_ = SubpassContents::eInline ) + : contents( contents_ ) + {} + + SubpassBeginInfoKHR( VkSubpassBeginInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SubpassBeginInfoKHR ) ); + } + + SubpassBeginInfoKHR& operator=( VkSubpassBeginInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SubpassBeginInfoKHR ) ); + return *this; + } + + SubpassBeginInfoKHR & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SubpassBeginInfoKHR & setContents( SubpassContents contents_ ) + { + contents = contents_; + return *this; + } + + operator VkSubpassBeginInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSubpassBeginInfoKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( SubpassBeginInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( contents == rhs.contents ); + } + + bool operator!=( SubpassBeginInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSubpassBeginInfoKHR; + + public: + const void* pNext = nullptr; + SubpassContents contents; + }; + static_assert( sizeof( SubpassBeginInfoKHR ) == sizeof( VkSubpassBeginInfoKHR ), "struct and wrapper have different size!" ); + + struct SubpassDescriptionDepthStencilResolveKHR + { + SubpassDescriptionDepthStencilResolveKHR( ResolveModeFlagBitsKHR depthResolveMode_ = ResolveModeFlagBitsKHR::eNone, + ResolveModeFlagBitsKHR stencilResolveMode_ = ResolveModeFlagBitsKHR::eNone, + const AttachmentReference2KHR* pDepthStencilResolveAttachment_ = nullptr ) + : depthResolveMode( depthResolveMode_ ) + , stencilResolveMode( stencilResolveMode_ ) + , pDepthStencilResolveAttachment( pDepthStencilResolveAttachment_ ) + {} + + SubpassDescriptionDepthStencilResolveKHR( VkSubpassDescriptionDepthStencilResolveKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SubpassDescriptionDepthStencilResolveKHR ) ); + } + + SubpassDescriptionDepthStencilResolveKHR& operator=( VkSubpassDescriptionDepthStencilResolveKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SubpassDescriptionDepthStencilResolveKHR ) ); + return *this; + } + + SubpassDescriptionDepthStencilResolveKHR & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SubpassDescriptionDepthStencilResolveKHR & setDepthResolveMode( ResolveModeFlagBitsKHR depthResolveMode_ ) + { + depthResolveMode = depthResolveMode_; + return *this; + } + + SubpassDescriptionDepthStencilResolveKHR & setStencilResolveMode( ResolveModeFlagBitsKHR stencilResolveMode_ ) + { + stencilResolveMode = stencilResolveMode_; + return *this; + } + + SubpassDescriptionDepthStencilResolveKHR & setPDepthStencilResolveAttachment( const AttachmentReference2KHR* pDepthStencilResolveAttachment_ ) + { + pDepthStencilResolveAttachment = pDepthStencilResolveAttachment_; + return *this; + } + + operator VkSubpassDescriptionDepthStencilResolveKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSubpassDescriptionDepthStencilResolveKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( SubpassDescriptionDepthStencilResolveKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( depthResolveMode == rhs.depthResolveMode ) + && ( stencilResolveMode == rhs.stencilResolveMode ) + && ( pDepthStencilResolveAttachment == rhs.pDepthStencilResolveAttachment ); + } + + bool operator!=( SubpassDescriptionDepthStencilResolveKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSubpassDescriptionDepthStencilResolveKHR; + + public: + const void* pNext = nullptr; + ResolveModeFlagBitsKHR depthResolveMode; + ResolveModeFlagBitsKHR stencilResolveMode; + const AttachmentReference2KHR* pDepthStencilResolveAttachment; + }; + static_assert( sizeof( SubpassDescriptionDepthStencilResolveKHR ) == sizeof( VkSubpassDescriptionDepthStencilResolveKHR ), "struct and wrapper have different size!" ); + + struct SubpassEndInfoKHR + { + SubpassEndInfoKHR( ) + {} + + SubpassEndInfoKHR( VkSubpassEndInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SubpassEndInfoKHR ) ); + } + + SubpassEndInfoKHR& operator=( VkSubpassEndInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SubpassEndInfoKHR ) ); + return *this; + } + + SubpassEndInfoKHR & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + operator VkSubpassEndInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSubpassEndInfoKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( SubpassEndInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ); + } + + bool operator!=( SubpassEndInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSubpassEndInfoKHR; + + public: + const void* pNext = nullptr; + }; + static_assert( sizeof( SubpassEndInfoKHR ) == sizeof( VkSubpassEndInfoKHR ), "struct and wrapper have different size!" ); + + struct SurfaceCapabilities2EXT + { + operator VkSurfaceCapabilities2EXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCapabilities2EXT &() + { + 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 SurfaceCapabilitiesKHR + { + operator VkSurfaceCapabilitiesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCapabilitiesKHR &() + { + 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 VkSurfaceCapabilities2KHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCapabilities2KHR &() + { + 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 SurfaceFormatKHR + { + operator VkSurfaceFormatKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceFormatKHR &() + { + 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 VkSurfaceFormat2KHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceFormat2KHR &() + { + 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!" ); + + 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 VkSwapchainCounterCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainCounterCreateInfoEXT &() + { + 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!" ); + + 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 VkSwapchainCreateInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainCreateInfoKHR &() + { + 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!" ); + + struct TextureLODGatherFormatPropertiesAMD + { + operator VkTextureLODGatherFormatPropertiesAMD const&() const + { + return *reinterpret_cast( this ); + } + + operator VkTextureLODGatherFormatPropertiesAMD &() + { + 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 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 VkValidationCacheCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkValidationCacheCreateInfoEXT &() + { + 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 ValidationFeaturesEXT + { + ValidationFeaturesEXT( uint32_t enabledValidationFeatureCount_ = 0, + const ValidationFeatureEnableEXT* pEnabledValidationFeatures_ = nullptr, + uint32_t disabledValidationFeatureCount_ = 0, + const ValidationFeatureDisableEXT* pDisabledValidationFeatures_ = nullptr ) + : enabledValidationFeatureCount( enabledValidationFeatureCount_ ) + , pEnabledValidationFeatures( pEnabledValidationFeatures_ ) + , disabledValidationFeatureCount( disabledValidationFeatureCount_ ) + , pDisabledValidationFeatures( pDisabledValidationFeatures_ ) + {} + + ValidationFeaturesEXT( VkValidationFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ValidationFeaturesEXT ) ); + } + + ValidationFeaturesEXT& operator=( VkValidationFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ValidationFeaturesEXT ) ); + return *this; + } + + ValidationFeaturesEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ValidationFeaturesEXT & setEnabledValidationFeatureCount( uint32_t enabledValidationFeatureCount_ ) + { + enabledValidationFeatureCount = enabledValidationFeatureCount_; + return *this; + } + + ValidationFeaturesEXT & setPEnabledValidationFeatures( const ValidationFeatureEnableEXT* pEnabledValidationFeatures_ ) + { + pEnabledValidationFeatures = pEnabledValidationFeatures_; + return *this; + } + + ValidationFeaturesEXT & setDisabledValidationFeatureCount( uint32_t disabledValidationFeatureCount_ ) + { + disabledValidationFeatureCount = disabledValidationFeatureCount_; + return *this; + } + + ValidationFeaturesEXT & setPDisabledValidationFeatures( const ValidationFeatureDisableEXT* pDisabledValidationFeatures_ ) + { + pDisabledValidationFeatures = pDisabledValidationFeatures_; + return *this; + } + + operator VkValidationFeaturesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkValidationFeaturesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( ValidationFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( enabledValidationFeatureCount == rhs.enabledValidationFeatureCount ) + && ( pEnabledValidationFeatures == rhs.pEnabledValidationFeatures ) + && ( disabledValidationFeatureCount == rhs.disabledValidationFeatureCount ) + && ( pDisabledValidationFeatures == rhs.pDisabledValidationFeatures ); + } + + bool operator!=( ValidationFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eValidationFeaturesEXT; + + public: + const void* pNext = nullptr; + uint32_t enabledValidationFeatureCount; + const ValidationFeatureEnableEXT* pEnabledValidationFeatures; + uint32_t disabledValidationFeatureCount; + const ValidationFeatureDisableEXT* pDisabledValidationFeatures; + }; + static_assert( sizeof( ValidationFeaturesEXT ) == sizeof( VkValidationFeaturesEXT ), "struct and wrapper have different size!" ); + + struct ValidationFlagsEXT + { + ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0, + const 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( const ValidationCheckEXT* pDisabledValidationChecks_ ) + { + pDisabledValidationChecks = pDisabledValidationChecks_; + return *this; + } + + operator VkValidationFlagsEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkValidationFlagsEXT &() + { + 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; + const ValidationCheckEXT* pDisabledValidationChecks; + }; + static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" ); + +#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 VkViSurfaceCreateInfoNN const&() const + { + return *reinterpret_cast( this ); + } + + operator VkViSurfaceCreateInfoNN &() + { + 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 VkWaylandSurfaceCreateInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkWaylandSurfaceCreateInfoKHR &() + { + 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 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 VkWin32KeyedMutexAcquireReleaseInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkWin32KeyedMutexAcquireReleaseInfoKHR &() + { + 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 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 VkWin32KeyedMutexAcquireReleaseInfoNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkWin32KeyedMutexAcquireReleaseInfoNV &() + { + 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_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 VkWin32SurfaceCreateInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkWin32SurfaceCreateInfoKHR &() + { + 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*/ + + 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 VkWriteDescriptorSet const&() const + { + return *reinterpret_cast( this ); + } + + operator VkWriteDescriptorSet &() + { + 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 WriteDescriptorSetAccelerationStructureNV + { + WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = 0, + const AccelerationStructureNV* pAccelerationStructures_ = nullptr ) + : accelerationStructureCount( accelerationStructureCount_ ) + , pAccelerationStructures( pAccelerationStructures_ ) + {} + + WriteDescriptorSetAccelerationStructureNV( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) + { + memcpy( this, &rhs, sizeof( WriteDescriptorSetAccelerationStructureNV ) ); + } + + WriteDescriptorSetAccelerationStructureNV& operator=( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) + { + memcpy( this, &rhs, sizeof( WriteDescriptorSetAccelerationStructureNV ) ); + return *this; + } + + WriteDescriptorSetAccelerationStructureNV & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + WriteDescriptorSetAccelerationStructureNV & setAccelerationStructureCount( uint32_t accelerationStructureCount_ ) + { + accelerationStructureCount = accelerationStructureCount_; + return *this; + } + + WriteDescriptorSetAccelerationStructureNV & setPAccelerationStructures( const AccelerationStructureNV* pAccelerationStructures_ ) + { + pAccelerationStructures = pAccelerationStructures_; + return *this; + } + + operator VkWriteDescriptorSetAccelerationStructureNV const&() const + { + return *reinterpret_cast( this ); + } + + operator VkWriteDescriptorSetAccelerationStructureNV &() + { + return *reinterpret_cast( this ); + } + + bool operator==( WriteDescriptorSetAccelerationStructureNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( accelerationStructureCount == rhs.accelerationStructureCount ) + && ( pAccelerationStructures == rhs.pAccelerationStructures ); + } + + bool operator!=( WriteDescriptorSetAccelerationStructureNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureNV; + + public: + const void* pNext = nullptr; + uint32_t accelerationStructureCount; + const AccelerationStructureNV* pAccelerationStructures; + }; + static_assert( sizeof( WriteDescriptorSetAccelerationStructureNV ) == sizeof( VkWriteDescriptorSetAccelerationStructureNV ), "struct and wrapper have different size!" ); + + struct WriteDescriptorSetInlineUniformBlockEXT + { + WriteDescriptorSetInlineUniformBlockEXT( uint32_t dataSize_ = 0, + const void* pData_ = nullptr ) + : dataSize( dataSize_ ) + , pData( pData_ ) + {} + + WriteDescriptorSetInlineUniformBlockEXT( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( WriteDescriptorSetInlineUniformBlockEXT ) ); + } + + WriteDescriptorSetInlineUniformBlockEXT& operator=( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( WriteDescriptorSetInlineUniformBlockEXT ) ); + return *this; + } + + WriteDescriptorSetInlineUniformBlockEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + WriteDescriptorSetInlineUniformBlockEXT & setDataSize( uint32_t dataSize_ ) + { + dataSize = dataSize_; + return *this; + } + + WriteDescriptorSetInlineUniformBlockEXT & setPData( const void* pData_ ) + { + pData = pData_; + return *this; + } + + operator VkWriteDescriptorSetInlineUniformBlockEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkWriteDescriptorSetInlineUniformBlockEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( WriteDescriptorSetInlineUniformBlockEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( dataSize == rhs.dataSize ) + && ( pData == rhs.pData ); + } + + bool operator!=( WriteDescriptorSetInlineUniformBlockEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eWriteDescriptorSetInlineUniformBlockEXT; + + public: + const void* pNext = nullptr; + uint32_t dataSize; + const void* pData; + }; + static_assert( sizeof( WriteDescriptorSetInlineUniformBlockEXT ) == sizeof( VkWriteDescriptorSetInlineUniformBlockEXT ), "struct and wrapper have different size!" ); + +#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 VkXcbSurfaceCreateInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkXcbSurfaceCreateInfoKHR &() + { + 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*/ + +#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 VkXlibSurfaceCreateInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkXlibSurfaceCreateInfoKHR &() + { + 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*/ + + 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 typename 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, d ); + return createResultValue( result, instance, VULKAN_HPP_NAMESPACE_STRING"::createInstanceUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + } + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceExtensionProperties" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type enumerateInstanceExtensionProperties( Optional layerName, Allocator const& vectorAllocator, Dispatch const &d ) + { + std::vector properties( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + } + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceExtensionProperties" ); + } +#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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + } + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceLayerProperties" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type enumerateInstanceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d ) + { + std::vector properties( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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 + 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 + 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*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, Dispatch const &d) const + { + d.vkCmdBeginConditionalRenderingEXT( m_commandBuffer, reinterpret_cast( pConditionalRenderingBegin ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, Dispatch const &d ) const + { + d.vkCmdBeginConditionalRenderingEXT( m_commandBuffer, reinterpret_cast( &conditionalRenderingBegin ) ); + } +#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::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::beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d) const + { + d.vkCmdBeginQueryIndexedEXT( m_commandBuffer, static_cast( queryPool ), query, static_cast( flags ), index ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d ) const + { + d.vkCmdBeginQueryIndexedEXT( m_commandBuffer, static_cast( queryPool ), query, static_cast( flags ), index ); + } +#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*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo* pRenderPassBegin, const SubpassBeginInfoKHR* pSubpassBeginInfo, Dispatch const &d) const + { + d.vkCmdBeginRenderPass2KHR( m_commandBuffer, reinterpret_cast( pRenderPassBegin ), reinterpret_cast( pSubpassBeginInfo ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, const SubpassBeginInfoKHR & subpassBeginInfo, Dispatch const &d ) const + { + d.vkCmdBeginRenderPass2KHR( m_commandBuffer, reinterpret_cast( &renderPassBegin ), reinterpret_cast( &subpassBeginInfo ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d) const + { + d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBufferCount, reinterpret_cast( pCounterBuffers ), reinterpret_cast( pCounterBufferOffsets ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy counterBuffers, ArrayProxy counterBufferOffsets, Dispatch const &d ) const + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() ); +#else + if ( counterBuffers.size() != counterBufferOffsets.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::VkCommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); + } +#endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBuffers.size() , reinterpret_cast( counterBuffers.data() ), reinterpret_cast( counterBufferOffsets.data() ) ); + } +#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 ), static_cast( 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 ), static_cast( offset ), static_cast( indexType ) ); + } +#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*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d) const + { + d.vkCmdBindShadingRateImageNV( m_commandBuffer, static_cast( imageView ), static_cast( imageLayout ) ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d ) const + { + d.vkCmdBindShadingRateImageNV( m_commandBuffer, static_cast( imageView ), static_cast( imageLayout ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, const DeviceSize* pSizes, Dispatch const &d) const + { + d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, firstBinding, bindingCount, reinterpret_cast( pBuffers ), reinterpret_cast( pOffsets ), reinterpret_cast( pSizes ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, ArrayProxy buffers, ArrayProxy offsets, ArrayProxy sizes, 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 "::VkCommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" ); + } +#endif /*VULKAN_HPP_NO_EXCEPTIONS*/ +#ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( buffers.size() == sizes.size() ); +#else + if ( buffers.size() != sizes.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::VkCommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" ); + } +#endif /*VULKAN_HPP_NO_EXCEPTIONS*/ +#ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( offsets.size() == sizes.size() ); +#else + if ( offsets.size() != sizes.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::VkCommandBuffer::bindTransformFeedbackBuffersEXT: offsets.size() != sizes.size()" ); + } +#endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, firstBinding, buffers.size() , reinterpret_cast( buffers.data() ), reinterpret_cast( offsets.data() ), reinterpret_cast( sizes.data() ) ); + } +#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 ), reinterpret_cast( 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 "::VkCommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" ); + } +#endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + d.vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, buffers.size() , reinterpret_cast( buffers.data() ), reinterpret_cast( offsets.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::buildAccelerationStructureNV( const AccelerationStructureInfoNV* pInfo, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d) const + { + d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, reinterpret_cast( pInfo ), static_cast( instanceData ), static_cast( instanceOffset ), static_cast( update ), static_cast( dst ), static_cast( src ), static_cast( scratch ), static_cast( scratchOffset ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d ) const + { + d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, reinterpret_cast( &info ), static_cast( instanceData ), static_cast( instanceOffset ), static_cast( update ), static_cast( dst ), static_cast( src ), static_cast( scratch ), static_cast( scratchOffset ) ); + } +#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::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*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d) const + { + d.vkCmdCopyAccelerationStructureNV( m_commandBuffer, static_cast( dst ), static_cast( src ), static_cast( mode ) ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d ) const + { + d.vkCmdCopyAccelerationStructureNV( m_commandBuffer, static_cast( dst ), static_cast( src ), static_cast( mode ) ); + } +#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::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::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::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*/ + +#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 ), static_cast( dstOffset ), static_cast( 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 ), static_cast( dstOffset ), static_cast( stride ), static_cast( flags ) ); + } +#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::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::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::dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d) const + { + d.vkCmdDispatchIndirect( m_commandBuffer, static_cast( buffer ), static_cast( offset ) ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d ) const + { + d.vkCmdDispatchIndirect( m_commandBuffer, static_cast( buffer ), static_cast( offset ) ); + } +#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::drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const + { + d.vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast( buffer ), static_cast( 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 ), static_cast( offset ), drawCount, 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 ), static_cast( offset ), static_cast( countBuffer ), static_cast( 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 ), static_cast( offset ), static_cast( countBuffer ), static_cast( 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 ), static_cast( offset ), static_cast( countBuffer ), static_cast( 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 ), static_cast( offset ), static_cast( countBuffer ), static_cast( countBufferOffset ), maxDrawCount, stride ); + } +#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 ), static_cast( 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 ), static_cast( offset ), drawCount, stride ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d) const + { + d.vkCmdDrawIndirectByteCountEXT( m_commandBuffer, instanceCount, firstInstance, static_cast( counterBuffer ), static_cast( counterBufferOffset ), counterOffset, vertexStride ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d ) const + { + d.vkCmdDrawIndirectByteCountEXT( m_commandBuffer, instanceCount, firstInstance, static_cast( counterBuffer ), static_cast( counterBufferOffset ), counterOffset, vertexStride ); + } +#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 ), static_cast( offset ), static_cast( countBuffer ), static_cast( 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 ), static_cast( offset ), static_cast( countBuffer ), static_cast( countBufferOffset ), maxDrawCount, stride ); + } +#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 ), static_cast( offset ), static_cast( countBuffer ), static_cast( 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 ), static_cast( offset ), static_cast( countBuffer ), static_cast( countBufferOffset ), maxDrawCount, stride ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const + { + d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer, static_cast( buffer ), static_cast( offset ), static_cast( countBuffer ), static_cast( countBufferOffset ), maxDrawCount, stride ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const + { + d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer, static_cast( buffer ), static_cast( offset ), static_cast( countBuffer ), static_cast( countBufferOffset ), maxDrawCount, stride ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const + { + d.vkCmdDrawMeshTasksIndirectNV( m_commandBuffer, static_cast( buffer ), static_cast( offset ), drawCount, stride ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const + { + d.vkCmdDrawMeshTasksIndirectNV( m_commandBuffer, static_cast( buffer ), static_cast( offset ), drawCount, stride ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const &d) const + { + d.vkCmdDrawMeshTasksNV( m_commandBuffer, taskCount, firstTask ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const &d ) const + { + d.vkCmdDrawMeshTasksNV( m_commandBuffer, taskCount, firstTask ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT(Dispatch const &d) const + { + d.vkCmdEndConditionalRenderingEXT( m_commandBuffer ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT(Dispatch const &d ) const + { + d.vkCmdEndConditionalRenderingEXT( m_commandBuffer ); + } +#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*/ + +#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::endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d) const + { + d.vkCmdEndQueryIndexedEXT( m_commandBuffer, static_cast( queryPool ), query, index ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d ) const + { + d.vkCmdEndQueryIndexedEXT( m_commandBuffer, static_cast( queryPool ), query, index ); + } +#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::endRenderPass2KHR( const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d) const + { + d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast( pSubpassEndInfo ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d ) const + { + d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast( &subpassEndInfo ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d) const + { + d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBufferCount, reinterpret_cast( pCounterBuffers ), reinterpret_cast( pCounterBufferOffsets ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy counterBuffers, ArrayProxy counterBufferOffsets, Dispatch const &d ) const + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() ); +#else + if ( counterBuffers.size() != counterBufferOffsets.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::VkCommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); + } +#endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBuffers.size() , reinterpret_cast( counterBuffers.data() ), reinterpret_cast( counterBufferOffsets.data() ) ); + } +#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*/ + +#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 ), static_cast( dstOffset ), static_cast( 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 ), static_cast( dstOffset ), static_cast( size ), data ); + } +#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::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*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfoKHR* pSubpassBeginInfo, const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d) const + { + d.vkCmdNextSubpass2KHR( m_commandBuffer, reinterpret_cast( pSubpassBeginInfo ), reinterpret_cast( pSubpassEndInfo ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfoKHR & subpassBeginInfo, const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d ) const + { + d.vkCmdNextSubpass2KHR( m_commandBuffer, reinterpret_cast( &subpassBeginInfo ), reinterpret_cast( &subpassEndInfo ) ); + } +#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*/ + + 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::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::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::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::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*/ + +#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*/ + +#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*/ + + 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::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::setCheckpointNV( const void* pCheckpointMarker, Dispatch const &d) const + { + d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void* pCheckpointMarker, Dispatch const &d ) const + { + d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d) const + { + d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, static_cast( sampleOrderType ), customSampleOrderCount, reinterpret_cast( pCustomSampleOrders ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy customSampleOrders, Dispatch const &d ) const + { + d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, static_cast( sampleOrderType ), customSampleOrders.size() , reinterpret_cast( customSampleOrders.data() ) ); + } +#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::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::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*/ + + 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*/ + +#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*/ + + template + VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const Rect2D* pExclusiveScissors, Dispatch const &d) const + { + d.vkCmdSetExclusiveScissorNV( m_commandBuffer, firstExclusiveScissor, exclusiveScissorCount, reinterpret_cast( pExclusiveScissors ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy exclusiveScissors, Dispatch const &d ) const + { + d.vkCmdSetExclusiveScissorNV( m_commandBuffer, firstExclusiveScissor, exclusiveScissors.size() , reinterpret_cast( exclusiveScissors.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*/ + + 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::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::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::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*/ + +#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*/ + + 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::setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d) const + { + d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast( pShadingRatePalettes ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy shadingRatePalettes, Dispatch const &d ) const + { + d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer, firstViewport, shadingRatePalettes.size() , reinterpret_cast( shadingRatePalettes.data() ) ); + } +#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*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d) const + { + d.vkCmdTraceRaysNV( m_commandBuffer, static_cast( raygenShaderBindingTableBuffer ), static_cast( raygenShaderBindingOffset ), static_cast( missShaderBindingTableBuffer ), static_cast( missShaderBindingOffset ), static_cast( missShaderBindingStride ), static_cast( hitShaderBindingTableBuffer ), static_cast( hitShaderBindingOffset ), static_cast( hitShaderBindingStride ), static_cast( callableShaderBindingTableBuffer ), static_cast( callableShaderBindingOffset ), static_cast( callableShaderBindingStride ), width, height, depth ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d ) const + { + d.vkCmdTraceRaysNV( m_commandBuffer, static_cast( raygenShaderBindingTableBuffer ), static_cast( raygenShaderBindingOffset ), static_cast( missShaderBindingTableBuffer ), static_cast( missShaderBindingOffset ), static_cast( missShaderBindingStride ), static_cast( hitShaderBindingTableBuffer ), static_cast( hitShaderBindingOffset ), static_cast( hitShaderBindingStride ), static_cast( callableShaderBindingTableBuffer ), static_cast( callableShaderBindingOffset ), static_cast( callableShaderBindingStride ), width, height, depth ); + } +#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 ), static_cast( dstOffset ), static_cast( 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 ), static_cast( dstOffset ), data.size() * sizeof( T ) , reinterpret_cast( data.data() ) ); + } +#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::writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const AccelerationStructureNV* pAccelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d) const + { + d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, accelerationStructureCount, reinterpret_cast( pAccelerationStructures ), static_cast( queryType ), static_cast( queryPool ), firstQuery ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( ArrayProxy accelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d ) const + { + d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, accelerationStructures.size() , reinterpret_cast( accelerationStructures.data() ), static_cast( queryType ), static_cast( queryPool ), firstQuery ); + } +#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 ), static_cast( 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 ), static_cast( dstOffset ), marker ); + } +#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 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*/ + + 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::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::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" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector commandBuffers( allocateInfo.commandBufferCount, vectorAllocator ); + 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,Allocator>>::type Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d ) const + { + static_assert( sizeof( CommandBuffer ) <= sizeof( UniqueHandle ), "CommandBuffer is greater than UniqueHandle!" ); + std::vector, Allocator> commandBuffers; + commandBuffers.reserve( allocateInfo.commandBufferCount ); + CommandBuffer* buffer = reinterpret_cast( reinterpret_cast( commandBuffers.data() ) + allocateInfo.commandBufferCount * ( sizeof( UniqueHandle ) - sizeof( CommandBuffer ) ) ); + Result result = static_cast(d.vkAllocateCommandBuffers( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( buffer ) ) ); + + PoolFree deleter( *this, allocateInfo.commandPool, d ); + for ( size_t i=0 ; i( buffer[i], deleter ) ); + } + + return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType,Allocator>>::type Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const + { + static_assert( sizeof( CommandBuffer ) <= sizeof( UniqueHandle ), "CommandBuffer is greater than UniqueHandle!" ); + std::vector, Allocator> commandBuffers( vectorAllocator ); + commandBuffers.reserve( allocateInfo.commandBufferCount ); + CommandBuffer* buffer = reinterpret_cast( reinterpret_cast( commandBuffers.data() ) + allocateInfo.commandBufferCount * ( sizeof( UniqueHandle ) - sizeof( CommandBuffer ) ) ); + Result result = static_cast(d.vkAllocateCommandBuffers( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( buffer ) ) ); + + PoolFree deleter( *this, allocateInfo.commandPool, d ); + for ( size_t i=0 ; i( buffer[i], deleter ) ); + } + + return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#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" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector descriptorSets( allocateInfo.descriptorSetCount, vectorAllocator ); + 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,Allocator>>::type Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d ) const + { + static_assert( sizeof( DescriptorSet ) <= sizeof( UniqueHandle ), "DescriptorSet is greater than UniqueHandle!" ); + std::vector, Allocator> descriptorSets; + descriptorSets.reserve( allocateInfo.descriptorSetCount ); + DescriptorSet* buffer = reinterpret_cast( reinterpret_cast( descriptorSets.data() ) + allocateInfo.descriptorSetCount * ( sizeof( UniqueHandle ) - sizeof( DescriptorSet ) ) ); + Result result = static_cast(d.vkAllocateDescriptorSets( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( buffer ) ) ); + + PoolFree deleter( *this, allocateInfo.descriptorPool, d ); + for ( size_t i=0 ; i( buffer[i], deleter ) ); + } + + return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType,Allocator>>::type Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const + { + static_assert( sizeof( DescriptorSet ) <= sizeof( UniqueHandle ), "DescriptorSet is greater than UniqueHandle!" ); + std::vector, Allocator> descriptorSets( vectorAllocator ); + descriptorSets.reserve( allocateInfo.descriptorSetCount ); + DescriptorSet* buffer = reinterpret_cast( reinterpret_cast( descriptorSets.data() ) + allocateInfo.descriptorSetCount * ( sizeof( UniqueHandle ) - sizeof( DescriptorSet ) ) ); + Result result = static_cast(d.vkAllocateDescriptorSets( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( buffer ) ) ); + + PoolFree deleter( *this, allocateInfo.descriptorPool, d ); + for ( size_t i=0 ; i( buffer[i], deleter ) ); + } + + return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#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 typename 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, d ); + 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 Result Device::bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d) const + { + return static_cast( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfoCount, reinterpret_cast( pBindInfos ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::bindAccelerationStructureMemoryNV( ArrayProxy bindInfos, Dispatch const &d ) const + { + Result result = static_cast( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfos.size() , reinterpret_cast( bindInfos.data() ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindAccelerationStructureMemoryNV" ); + } +#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 ), static_cast( 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 ), static_cast( memoryOffset ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory" ); + } +#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*/ + +#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 ), static_cast( 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 ), static_cast( memoryOffset ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory" ); + } +#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*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE Result Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d) const + { + return static_cast( d.vkCompileDeferredNV( m_device, static_cast( pipeline ), shader ) ); + } +#else + template + VULKAN_HPP_INLINE ResultValueType::type Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d ) const + { + Result result = static_cast( d.vkCompileDeferredNV( m_device, static_cast( pipeline ), shader ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::compileDeferredNV" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNV* pAccelerationStructure, Dispatch const &d) const + { + return static_cast( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pAccelerationStructure ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, Optional allocator, Dispatch const &d ) const + { + AccelerationStructureNV accelerationStructure; + Result result = static_cast( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &accelerationStructure ) ) ); + return createResultValue( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING"::Device::createAccelerationStructureNV" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, Optional allocator, Dispatch const &d ) const + { + AccelerationStructureNV accelerationStructure; + Result result = static_cast( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &accelerationStructure ) ) ); + + ObjectDestroy deleter( *this, allocator, d ); + return createResultValue( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING"::Device::createAccelerationStructureNVUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#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 typename 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, d ); + 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 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 typename 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, d ); + 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 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 typename 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, d ); + 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 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 typename ResultValueType>::type Device::createComputePipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector pipelines( createInfos.size(), vectorAllocator ); + 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,Allocator>>::type Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const + { + static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle ), "Pipeline is greater than UniqueHandle!" ); + std::vector, Allocator> pipelines; + pipelines.reserve( createInfos.size() ); + Pipeline* buffer = reinterpret_cast( reinterpret_cast( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle ) - 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, d ); + for ( size_t i=0 ; i( buffer[i], deleter ) ); + } + + return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType,Allocator>>::type Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const + { + static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle ), "Pipeline is greater than UniqueHandle!" ); + std::vector, Allocator> pipelines( vectorAllocator ); + pipelines.reserve( createInfos.size() ); + Pipeline* buffer = reinterpret_cast( reinterpret_cast( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle ) - 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, d ); + for ( size_t i=0 ; i( buffer[i], deleter ) ); + } + + return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique" ); + } + template + VULKAN_HPP_INLINE typename 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, d ); + 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 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 typename 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, d ); + 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 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 typename 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, d ); + 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 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 typename 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, d ); + 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 typename 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, d ); + 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 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 typename 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, d ); + 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 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 typename 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, d ); + 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 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 typename 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, d ); + 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 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 typename ResultValueType>::type Device::createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector pipelines( createInfos.size(), vectorAllocator ); + 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,Allocator>>::type Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const + { + static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle ), "Pipeline is greater than UniqueHandle!" ); + std::vector, Allocator> pipelines; + pipelines.reserve( createInfos.size() ); + Pipeline* buffer = reinterpret_cast( reinterpret_cast( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle ) - 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, d ); + for ( size_t i=0 ; i( buffer[i], deleter ) ); + } + + return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType,Allocator>>::type Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const + { + static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle ), "Pipeline is greater than UniqueHandle!" ); + std::vector, Allocator> pipelines( vectorAllocator ); + pipelines.reserve( createInfos.size() ); + Pipeline* buffer = reinterpret_cast( reinterpret_cast( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle ) - 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, d ); + for ( size_t i=0 ; i( buffer[i], deleter ) ); + } + + return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique" ); + } + template + VULKAN_HPP_INLINE typename 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, d ); + 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::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 typename 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, d ); + 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 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 typename 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, d ); + 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 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 typename 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, d ); + 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 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 typename 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, d ); + 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 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 typename 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, d ); + 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 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 typename 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, d ); + 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 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 typename 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, d ); + 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 Result Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, uint32_t createInfoCount, const RayTracingPipelineCreateInfoNV* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const + { + return static_cast( d.vkCreateRayTracingPipelinesNV( 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::createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const + { + std::vector pipelines( createInfos.size() ); + Result result = static_cast( d.vkCreateRayTracingPipelinesNV( 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::createRayTracingPipelinesNV" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector pipelines( createInfos.size(), vectorAllocator ); + Result result = static_cast( d.vkCreateRayTracingPipelinesNV( 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::createRayTracingPipelinesNV" ); + } + template + VULKAN_HPP_INLINE ResultValueType::type Device::createRayTracingPipelineNV( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional allocator, Dispatch const &d ) const + { + Pipeline pipeline; + Result result = static_cast( d.vkCreateRayTracingPipelinesNV( 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::createRayTracingPipelineNV" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE typename ResultValueType,Allocator>>::type Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const + { + static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle ), "Pipeline is greater than UniqueHandle!" ); + std::vector, Allocator> pipelines; + pipelines.reserve( createInfos.size() ); + Pipeline* buffer = reinterpret_cast( reinterpret_cast( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle ) - sizeof( Pipeline ) ) ); + Result result = static_cast(d.vkCreateRayTracingPipelinesNV( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( buffer ) ) ); + + ObjectDestroy deleter( *this, allocator, d ); + for ( size_t i=0 ; i( buffer[i], deleter ) ); + } + + return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType,Allocator>>::type Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const + { + static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle ), "Pipeline is greater than UniqueHandle!" ); + std::vector, Allocator> pipelines( vectorAllocator ); + pipelines.reserve( createInfos.size() ); + Pipeline* buffer = reinterpret_cast( reinterpret_cast( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle ) - sizeof( Pipeline ) ) ); + Result result = static_cast(d.vkCreateRayTracingPipelinesNV( m_device, static_cast( pipelineCache ), createInfos.size() , reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( buffer ) ) ); + + ObjectDestroy deleter( *this, allocator, d ); + for ( size_t i=0 ; i( buffer[i], deleter ) ); + } + + return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::createRayTracingPipelineNVUnique( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional allocator, Dispatch const &d ) const + { + Pipeline pipeline; + Result result = static_cast( d.vkCreateRayTracingPipelinesNV( m_device, static_cast( pipelineCache ), 1 , reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipeline ) ) ); + + ObjectDestroy deleter( *this, allocator, d ); + return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelineNVUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#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 typename 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, d ); + 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 Result Device::createRenderPass2KHR( const RenderPassCreateInfo2KHR* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d) const + { + return static_cast( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pRenderPass ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::createRenderPass2KHR( const RenderPassCreateInfo2KHR & createInfo, Optional allocator, Dispatch const &d ) const + { + RenderPass renderPass; + Result result = static_cast( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &renderPass ) ) ); + return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass2KHR" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::createRenderPass2KHRUnique( const RenderPassCreateInfo2KHR & createInfo, Optional allocator, Dispatch const &d ) const + { + RenderPass renderPass; + Result result = static_cast( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &renderPass ) ) ); + + ObjectDestroy deleter( *this, allocator, d ); + return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass2KHRUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#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 typename 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, d ); + 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 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 typename 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, d ); + 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 typename 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, d ); + 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 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 typename 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, d ); + 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 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 typename 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, d ); + 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 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 typename ResultValueType>::type Device::createSharedSwapchainsKHR( ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector swapchains( createInfos.size(), vectorAllocator ); + 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,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy createInfos, Optional allocator, Dispatch const &d ) const + { + static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueHandle ), "SwapchainKHR is greater than UniqueHandle!" ); + std::vector, Allocator> swapchainKHRs; + swapchainKHRs.reserve( createInfos.size() ); + SwapchainKHR* buffer = reinterpret_cast( reinterpret_cast( swapchainKHRs.data() ) + createInfos.size() * ( sizeof( UniqueHandle ) - 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, d ); + for ( size_t i=0 ; i( buffer[i], deleter ) ); + } + + return createResultValue( result, swapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy createInfos, Optional allocator, Allocator const& vectorAllocator, Dispatch const &d ) const + { + static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueHandle ), "SwapchainKHR is greater than UniqueHandle!" ); + std::vector, Allocator> swapchainKHRs( vectorAllocator ); + swapchainKHRs.reserve( createInfos.size() ); + SwapchainKHR* buffer = reinterpret_cast( reinterpret_cast( swapchainKHRs.data() ) + createInfos.size() * ( sizeof( UniqueHandle ) - 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, d ); + for ( size_t i=0 ; i( buffer[i], deleter ) ); + } + + return createResultValue( result, swapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" ); + } + template + VULKAN_HPP_INLINE typename 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, d ); + 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 typename 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, d ); + 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 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 typename 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, d ); + 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 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*/ + + template + VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyAccelerationStructureNV( m_device, static_cast( accelerationStructure ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyAccelerationStructureNV( m_device, static_cast( accelerationStructure ), reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const + { + d.vkDestroyAccelerationStructureNV( m_device, static_cast( accelerationStructure ), reinterpret_cast( pAllocator ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure, Optional allocator, Dispatch const &d ) const + { + d.vkDestroyAccelerationStructureNV( m_device, static_cast( accelerationStructure ), reinterpret_cast( static_cast( allocator ) ) ); + } +#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 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 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*/ + + 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*/ + + 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 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*/ + + 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::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*/ + + 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 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 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::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 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 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 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 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 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 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 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::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 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::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 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 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 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*/ + +#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::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::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 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::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::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::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d) const + { + return static_cast( d.vkGetAccelerationStructureHandleNV( m_device, static_cast( accelerationStructure ), dataSize, pData ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, ArrayProxy data, Dispatch const &d ) const + { + Result result = static_cast( d.vkGetAccelerationStructureHandleNV( m_device, static_cast( accelerationStructure ), data.size() * sizeof( T ) , reinterpret_cast( data.data() ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getAccelerationStructureHandleNV" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE void Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d) const + { + d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast( pInfo ), reinterpret_cast( pMemoryRequirements ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d ) const + { + MemoryRequirements2KHR memoryRequirements; + d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; + } + template + VULKAN_HPP_INLINE StructureChain Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d ) const + { + StructureChain structureChain; + MemoryRequirements2KHR& memoryRequirements = structureChain.template get(); + d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + 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_KHR*/ + + template + VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfoEXT* pInfo, Dispatch const &d) const + { + return static_cast( d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast( pInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfoEXT & info, Dispatch const &d ) const + { + return d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast( &info ) ); + } +#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*/ + + 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 Result Device::getCalibratedTimestampsEXT( uint32_t timestampCount, const CalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, Dispatch const &d) const + { + return static_cast( d.vkGetCalibratedTimestampsEXT( m_device, timestampCount, reinterpret_cast( pTimestampInfos ), pTimestamps, pMaxDeviation ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getCalibratedTimestampsEXT( ArrayProxy timestampInfos, ArrayProxy timestamps, Dispatch const &d ) const + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( timestampInfos.size() == timestamps.size() ); +#else + if ( timestampInfos.size() != timestamps.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::VkDevice::getCalibratedTimestampsEXT: timestampInfos.size() != timestamps.size()" ); + } +#endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + uint64_t maxDeviation; + Result result = static_cast( d.vkGetCalibratedTimestampsEXT( m_device, timestampInfos.size() , reinterpret_cast( timestampInfos.data() ), timestamps.data(), &maxDeviation ) ); + return createResultValue( result, maxDeviation, VULKAN_HPP_NAMESPACE_STRING"::Device::getCalibratedTimestampsEXT" ); + } +#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 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::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 void Device::getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes, Dispatch const &d) const + { + d.vkGetDeviceMemoryCommitment( m_device, static_cast( memory ), reinterpret_cast( 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 ), reinterpret_cast( &committedMemoryInBytes ) ); + return committedMemoryInBytes; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + 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::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*/ + + 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*/ + +#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*/ + + 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*/ + +#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*/ + +#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*/ + + template + VULKAN_HPP_INLINE Result Device::getImageDrmFormatModifierPropertiesEXT( Image image, ImageDrmFormatModifierPropertiesEXT* pProperties, Dispatch const &d) const + { + return static_cast( d.vkGetImageDrmFormatModifierPropertiesEXT( m_device, static_cast( image ), reinterpret_cast( pProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const &d ) const + { + ImageDrmFormatModifierPropertiesEXT properties; + Result result = static_cast( d.vkGetImageDrmFormatModifierPropertiesEXT( m_device, static_cast( image ), reinterpret_cast( &properties ) ) ); + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getImageDrmFormatModifierPropertiesEXT" ); + } +#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*/ + + 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::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; + } + template + VULKAN_HPP_INLINE std::vector Device::getImageSparseMemoryRequirements( Image image, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector sparseMemoryRequirements( vectorAllocator ); + 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 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; + } + template + VULKAN_HPP_INLINE std::vector Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector sparseMemoryRequirements( vectorAllocator ); + 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; + } + template + VULKAN_HPP_INLINE std::vector Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector sparseMemoryRequirements( vectorAllocator ); + 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 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*/ + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + 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_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*/ + + 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_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::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_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::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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); + presentationTimings.resize( presentationTimingCount ); + } + return createResultValue( result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING"::Device::getPastPresentationTimingGOOGLE" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector presentationTimings( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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 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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( dataSize <= data.size() ); + data.resize( dataSize ); + } + return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineCacheData" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getPipelineCacheData( PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector data( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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::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, static_cast( 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() ), static_cast( 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::getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d) const + { + return static_cast( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast( pipeline ), firstGroup, groupCount, dataSize, pData ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy data, Dispatch const &d ) const + { + Result result = static_cast( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast( data.data() ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getRayTracingShaderGroupHandlesNV" ); + } +#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 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::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*/ + +#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*/ + + 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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( infoSize <= info.size() ); + info.resize( infoSize ); + } + return createResultValue( result, info, VULKAN_HPP_NAMESPACE_STRING"::Device::getShaderInfoAMD" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector info( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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::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 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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() ); + swapchainImages.resize( swapchainImageCount ); + } + return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainImagesKHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getSwapchainImagesKHR( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector swapchainImages( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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*/ + +#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::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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( dataSize <= data.size() ); + data.resize( dataSize ); + } + return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getValidationCacheDataEXT" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector data( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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::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*/ + +#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::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::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::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 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 ), static_cast( offset ), static_cast( 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 ), static_cast( offset ), static_cast( size ), static_cast( flags ), &pData ) ); + return createResultValue( result, pData, VULKAN_HPP_NAMESPACE_STRING"::Device::mapMemory" ); + } +#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::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 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::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 "::VkDevice::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*/ + +#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*/ + +#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*/ + +#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::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*/ + + 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*/ + +#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*/ + + 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 "::VkDevice::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 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 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::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 "::VkDevice::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::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::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::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 ), static_cast( 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() ), static_cast( waitAll ), timeout ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::waitForFences", { Result::eSuccess, Result::eTimeout } ); + } +#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 typename 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, d ); + 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::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 typename 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, d ); + 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 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 typename 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, d ); + 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 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 typename 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, d ); + 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_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 typename 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, d ); + 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_FUCHSIA + template + VULKAN_HPP_INLINE Result Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const + { + return static_cast( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast( pCreateInfo ), reinterpret_cast( pAllocator ), reinterpret_cast( pSurface ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createImagePipeSurfaceFUCHSIA" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ) ); + + ObjectDestroy deleter( *this, allocator, d ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createImagePipeSurfaceFUCHSIAUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#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 typename 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, d ); + 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*/ + +#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 typename 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, d ); + 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 typename 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, d ); + 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 typename 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, d ); + 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_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 typename 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, d ); + 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*/ + +#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 typename 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, d ); + 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*/ + + 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 "::VkInstance::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 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::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::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 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*/ + + 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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + } + return createResultValue( result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDeviceGroups" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type Instance::enumeratePhysicalDeviceGroups(Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector physicalDeviceGroupProperties( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + } + return createResultValue( result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDeviceGroupsKHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type Instance::enumeratePhysicalDeviceGroupsKHR(Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector physicalDeviceGroupProperties( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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*/ + + 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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() ); + physicalDevices.resize( physicalDeviceCount ); + } + return createResultValue( result, physicalDevices, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDevices" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type Instance::enumeratePhysicalDevices(Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector physicalDevices( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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*/ + + 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*/ + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + 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_EXT*/ + + 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 typename 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, d ); + 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::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::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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + } + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceExtensionProperties" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::enumerateDeviceExtensionProperties( Optional layerName, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector properties( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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 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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + } + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceLayerProperties" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::enumerateDeviceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector properties( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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::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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + } + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModeProperties2KHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector properties( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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::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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + } + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModePropertiesKHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector properties( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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::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*/ + + 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*/ + + 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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( displayCount <= displays.size() ); + displays.resize( displayCount ); + } + return createResultValue( result, displays, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector displays( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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::getCalibrateableTimeDomainsEXT( uint32_t* pTimeDomainCount, TimeDomainEXT* pTimeDomains, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, pTimeDomainCount, reinterpret_cast( pTimeDomains ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getCalibrateableTimeDomainsEXT(Dispatch const &d ) const + { + std::vector timeDomains; + uint32_t timeDomainCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && timeDomainCount ) + { + timeDomains.resize( timeDomainCount ); + result = static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast( timeDomains.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); + timeDomains.resize( timeDomainCount ); + } + return createResultValue( result, timeDomains, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getCalibrateableTimeDomainsEXT" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getCalibrateableTimeDomainsEXT(Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector timeDomains( vectorAllocator ); + uint32_t timeDomainCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && timeDomainCount ) + { + timeDomains.resize( timeDomainCount ); + result = static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast( timeDomains.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); + timeDomains.resize( timeDomainCount ); + } + return createResultValue( result, timeDomains, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getCalibrateableTimeDomainsEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeMatrixPropertiesNV( uint32_t* pPropertyCount, CooperativeMatrixPropertiesNV* pProperties, Dispatch const &d) const + { + return static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, pPropertyCount, reinterpret_cast( pProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getCooperativeMatrixPropertiesNV(Dispatch const &d ) const + { + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + } + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getCooperativeMatrixPropertiesNV" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getCooperativeMatrixPropertiesNV(Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector properties( vectorAllocator ); + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + } + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getCooperativeMatrixPropertiesNV" ); + } +#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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + } + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneProperties2KHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPlaneProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector properties( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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::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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + } + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlanePropertiesKHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPlanePropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector properties( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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::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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + } + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayProperties2KHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector properties( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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::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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + properties.resize( propertyCount ); + } + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPropertiesKHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector properties( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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 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::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*/ + + 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::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::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::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::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 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; + } + template + VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFormatProperties2( Format format, Dispatch const &d ) const + { + StructureChain structureChain; + FormatProperties2& formatProperties = structureChain.template get(); + d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); + return structureChain; + } +#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; + } + template + VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFormatProperties2KHR( Format format, Dispatch const &d ) const + { + StructureChain structureChain; + FormatProperties2& formatProperties = structureChain.template get(); + d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); + return structureChain; + } +#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 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::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::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::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; + } + template + VULKAN_HPP_INLINE StructureChain PhysicalDevice::getMemoryProperties2(Dispatch const &d ) const + { + StructureChain structureChain; + PhysicalDeviceMemoryProperties2& memoryProperties = structureChain.template get(); + d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); + return structureChain; + } +#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; + } + template + VULKAN_HPP_INLINE StructureChain PhysicalDevice::getMemoryProperties2KHR(Dispatch const &d ) const + { + StructureChain structureChain; + PhysicalDeviceMemoryProperties2& memoryProperties = structureChain.template get(); + d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); + return structureChain; + } +#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::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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( rectCount <= rects.size() ); + rects.resize( rectCount ); + } + return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getPresentRectanglesKHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector rects( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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::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::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::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; + } + template + VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties(Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector queueFamilyProperties( vectorAllocator ); + 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::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; + } + template + VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties2(Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector queueFamilyProperties( vectorAllocator ); + uint32_t queueFamilyPropertyCount; + d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + return queueFamilyProperties; + } + 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; + } + template + VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties2(Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector queueFamilyProperties( vectorAllocator ); + 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; + } + template + VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector queueFamilyProperties( vectorAllocator ); + uint32_t queueFamilyPropertyCount; + d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + return queueFamilyProperties; + } + 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; + } + template + VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector queueFamilyProperties( vectorAllocator ); + 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::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; + } + template + VULKAN_HPP_INLINE std::vector PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector properties( vectorAllocator ); + 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 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; + } + template + VULKAN_HPP_INLINE std::vector PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector properties( vectorAllocator ); + 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; + } + template + VULKAN_HPP_INLINE std::vector PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector properties( vectorAllocator ); + 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 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::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::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::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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); + surfaceFormats.resize( surfaceFormatCount ); + } + return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormats2KHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector surfaceFormats( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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::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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); + surfaceFormats.resize( surfaceFormatCount ); + } + return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormatsKHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector surfaceFormats( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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 ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); + presentModes.resize( presentModeCount ); + } + return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfacePresentModesKHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector presentModes( vectorAllocator ); + 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 ); + if ( result == Result::eSuccess ) + { + 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*/ + + 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 ), reinterpret_cast( 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 ), reinterpret_cast( &supported ) ) ); + return createResultValue( result, supported, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceSupportKHR" ); + } +#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 static_cast( 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 static_cast( 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_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 static_cast( 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*/ + +#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 static_cast( 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_XLIB_XRANDR_EXT + 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_EXT*/ + +#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*/ + + template + VULKAN_HPP_INLINE void Queue::getCheckpointDataNV( uint32_t* pCheckpointDataCount, CheckpointDataNV* pCheckpointData, Dispatch const &d) const + { + d.vkGetQueueCheckpointDataNV( m_queue, pCheckpointDataCount, reinterpret_cast( pCheckpointData ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE std::vector Queue::getCheckpointDataNV(Dispatch const &d ) const + { + std::vector checkpointData; + uint32_t checkpointDataCount; + d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr ); + checkpointData.resize( checkpointDataCount ); + d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, reinterpret_cast( checkpointData.data() ) ); + return checkpointData; + } + template + VULKAN_HPP_INLINE std::vector Queue::getCheckpointDataNV(Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector checkpointData( vectorAllocator ); + uint32_t checkpointDataCount; + d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr ); + checkpointData.resize( checkpointDataCount ); + d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, reinterpret_cast( checkpointData.data() ) ); + return checkpointData; + } +#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*/ + + 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*/ + +#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*/ + + 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 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*/ + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ +#ifdef VK_USE_PLATFORM_ANDROID_KHR + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_ANDROID_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 }; }; +#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 }; }; +#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 }; }; +#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 }; }; +#ifdef VK_USE_PLATFORM_WIN32_KHR + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_ANDROID_KHR + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_ANDROID_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 }; }; +#ifdef VK_USE_PLATFORM_ANDROID_KHR + template <> struct isStructureChainValid{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + 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*/ + 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 }; }; + 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 }; }; + 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_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 }; }; + + class DispatchLoaderDynamic + { + public: + PFN_vkCreateInstance vkCreateInstance = 0; + PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0; + PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0; + PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0; + PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0; + PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = 0; + PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0; + PFN_vkCmdBeginQuery vkCmdBeginQuery = 0; + PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT = 0; + PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0; + PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = 0; + PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT = 0; + PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0; + PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0; + PFN_vkCmdBindPipeline vkCmdBindPipeline = 0; + PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV = 0; + PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = 0; + PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0; + PFN_vkCmdBlitImage vkCmdBlitImage = 0; + PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV = 0; + PFN_vkCmdClearAttachments vkCmdClearAttachments = 0; + PFN_vkCmdClearColorImage vkCmdClearColorImage = 0; + PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0; + PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV = 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_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT = 0; + PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0; + PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0; + PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0; + PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = 0; + PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV = 0; + PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT = 0; + PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0; + PFN_vkCmdEndQuery vkCmdEndQuery = 0; + PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT = 0; + PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0; + PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR = 0; + PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT = 0; + PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0; + PFN_vkCmdFillBuffer vkCmdFillBuffer = 0; + PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0; + PFN_vkCmdNextSubpass vkCmdNextSubpass = 0; + PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR = 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_vkCmdSetCheckpointNV vkCmdSetCheckpointNV = 0; + PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV = 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_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 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_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = 0; + PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0; + PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV = 0; + PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0; + PFN_vkCmdWaitEvents vkCmdWaitEvents = 0; + PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0; + PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0; + PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0; + PFN_vkEndCommandBuffer vkEndCommandBuffer = 0; + PFN_vkResetCommandBuffer vkResetCommandBuffer = 0; + PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0; + PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0; + PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0; + PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0; + PFN_vkAllocateMemory vkAllocateMemory = 0; + PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 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_vkCompileDeferredNV vkCompileDeferredNV = 0; + PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = 0; + PFN_vkCreateBuffer vkCreateBuffer = 0; + PFN_vkCreateBufferView vkCreateBufferView = 0; + PFN_vkCreateCommandPool vkCreateCommandPool = 0; + PFN_vkCreateComputePipelines vkCreateComputePipelines = 0; + PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0; + PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0; + PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0; + PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = 0; + PFN_vkCreateEvent vkCreateEvent = 0; + PFN_vkCreateFence vkCreateFence = 0; + PFN_vkCreateFramebuffer vkCreateFramebuffer = 0; + PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0; + PFN_vkCreateImage vkCreateImage = 0; + PFN_vkCreateImageView vkCreateImageView = 0; + PFN_vkCreateIndirectCommandsLayoutNVX vkCreateIndirectCommandsLayoutNVX = 0; + PFN_vkCreateObjectTableNVX vkCreateObjectTableNVX = 0; + PFN_vkCreatePipelineCache vkCreatePipelineCache = 0; + PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0; + PFN_vkCreateQueryPool vkCreateQueryPool = 0; + PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = 0; + PFN_vkCreateRenderPass vkCreateRenderPass = 0; + PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 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; + PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0; + PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0; + PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0; + PFN_vkDestroyBuffer vkDestroyBuffer = 0; + PFN_vkDestroyBufferView vkDestroyBufferView = 0; + PFN_vkDestroyCommandPool vkDestroyCommandPool = 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_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_vkDestroySwapchainKHR vkDestroySwapchainKHR = 0; + PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = 0; + PFN_vkDeviceWaitIdle vkDeviceWaitIdle = 0; + PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0; + PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = 0; + PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0; + PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0; + PFN_vkFreeMemory vkFreeMemory = 0; + PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = 0; + PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0; +#ifdef VK_USE_PLATFORM_ANDROID_KHR + PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0; + PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0; + PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0; + PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0; + PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 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_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_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT = 0; + 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; +#ifdef VK_USE_PLATFORM_ANDROID_KHR + PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + 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_KHR + PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0; + PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0; + PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0; + PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0; + 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_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0; + PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0; + PFN_vkRegisterObjectsNVX vkRegisterObjectsNVX = 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_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; +#ifdef VK_USE_PLATFORM_ANDROID_KHR + PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0; + PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0; + PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0; +#ifdef VK_USE_PLATFORM_IOS_MVK + PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0; +#endif /*VK_USE_PLATFORM_IOS_MVK*/ +#ifdef VK_USE_PLATFORM_FUCHSIA + PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ +#ifdef VK_USE_PLATFORM_MACOS_MVK + PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0; +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ +#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_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0; + PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0; + PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0; + PFN_vkDestroyInstance vkDestroyInstance = 0; + PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0; + PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0; + PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0; + PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0; + PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0; + PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0; +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0; +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + PFN_vkCreateDevice vkCreateDevice = 0; + PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0; + PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0; + PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0; + PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0; + PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0; + PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0; + PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0; + PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0; + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0; + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 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; + 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*/ +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0; +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0; + PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV = 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; + + public: + DispatchLoaderDynamic() = default; + + DispatchLoaderDynamic( VkInstance instance, PFN_vkGetInstanceProcAddr getInstanceProcAddr, VkDevice device = VK_NULL_HANDLE, PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr ) + { + init( instance, getInstanceProcAddr, device, getDeviceProcAddr ); + } + + void init( VkInstance instance, PFN_vkGetInstanceProcAddr getInstanceProcAddr, VkDevice device = VK_NULL_HANDLE, PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr ) + { + assert(instance && getInstanceProcAddr); + assert(!!device == !!getDeviceProcAddr); + vkGetInstanceProcAddr = getInstanceProcAddr; + vkGetDeviceProcAddr = getDeviceProcAddr ? getDeviceProcAddr : PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr") ); + vkCreateInstance = PFN_vkCreateInstance( vkGetInstanceProcAddr( instance, "vkCreateInstance" ) ); + vkEnumerateInstanceExtensionProperties = PFN_vkEnumerateInstanceExtensionProperties( vkGetInstanceProcAddr( instance, "vkEnumerateInstanceExtensionProperties" ) ); + vkEnumerateInstanceLayerProperties = PFN_vkEnumerateInstanceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateInstanceLayerProperties" ) ); + vkEnumerateInstanceVersion = PFN_vkEnumerateInstanceVersion( vkGetInstanceProcAddr( instance, "vkEnumerateInstanceVersion" ) ); + vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( device ? vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) : vkGetInstanceProcAddr( instance, "vkBeginCommandBuffer" ) ); + vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( device ? vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdBeginConditionalRenderingEXT" ) ); + vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( device ? vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdBeginDebugUtilsLabelEXT" ) ); + vkCmdBeginQuery = PFN_vkCmdBeginQuery( device ? vkGetDeviceProcAddr( device, "vkCmdBeginQuery" ) : vkGetInstanceProcAddr( instance, "vkCmdBeginQuery" ) ); + vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( device ? vkGetDeviceProcAddr( device, "vkCmdBeginQueryIndexedEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdBeginQueryIndexedEXT" ) ); + vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( device ? vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) : vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass" ) ); + vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( device ? vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2KHR" ) : vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2KHR" ) ); + vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( device ? vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedbackEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdBeginTransformFeedbackEXT" ) ); + vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( device ? vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets" ) : vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorSets" ) ); + vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( device ? vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer" ) : vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer" ) ); + vkCmdBindPipeline = PFN_vkCmdBindPipeline( device ? vkGetDeviceProcAddr( device, "vkCmdBindPipeline" ) : vkGetInstanceProcAddr( instance, "vkCmdBindPipeline" ) ); + vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( device ? vkGetDeviceProcAddr( device, "vkCmdBindShadingRateImageNV" ) : vkGetInstanceProcAddr( instance, "vkCmdBindShadingRateImageNV" ) ); + vkCmdBindTransformFeedbackBuffersEXT = PFN_vkCmdBindTransformFeedbackBuffersEXT( device ? vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffersEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdBindTransformFeedbackBuffersEXT" ) ); + vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( device ? vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers" ) : vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers" ) ); + vkCmdBlitImage = PFN_vkCmdBlitImage( device ? vkGetDeviceProcAddr( device, "vkCmdBlitImage" ) : vkGetInstanceProcAddr( instance, "vkCmdBlitImage" ) ); + vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( device ? vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructureNV" ) : vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructureNV" ) ); + vkCmdClearAttachments = PFN_vkCmdClearAttachments( device ? vkGetDeviceProcAddr( device, "vkCmdClearAttachments" ) : vkGetInstanceProcAddr( instance, "vkCmdClearAttachments" ) ); + vkCmdClearColorImage = PFN_vkCmdClearColorImage( device ? vkGetDeviceProcAddr( device, "vkCmdClearColorImage" ) : vkGetInstanceProcAddr( instance, "vkCmdClearColorImage" ) ); + vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( device ? vkGetDeviceProcAddr( device, "vkCmdClearDepthStencilImage" ) : vkGetInstanceProcAddr( instance, "vkCmdClearDepthStencilImage" ) ); + vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( device ? vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureNV" ) : vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureNV" ) ); + vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( device ? vkGetDeviceProcAddr( device, "vkCmdCopyBuffer" ) : vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer" ) ); + vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( device ? vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage" ) : vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage" ) ); + vkCmdCopyImage = PFN_vkCmdCopyImage( device ? vkGetDeviceProcAddr( device, "vkCmdCopyImage" ) : vkGetInstanceProcAddr( instance, "vkCmdCopyImage" ) ); + vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( device ? vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer" ) : vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer" ) ); + vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( device ? vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) : vkGetInstanceProcAddr( instance, "vkCmdCopyQueryPoolResults" ) ); + vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( device ? vkGetDeviceProcAddr( device, "vkCmdDebugMarkerBeginEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerBeginEXT" ) ); + vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( device ? vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerEndEXT" ) ); + vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( device ? vkGetDeviceProcAddr( device, "vkCmdDebugMarkerInsertEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerInsertEXT" ) ); + vkCmdDispatch = PFN_vkCmdDispatch( device ? vkGetDeviceProcAddr( device, "vkCmdDispatch" ) : vkGetInstanceProcAddr( instance, "vkCmdDispatch" ) ); + vkCmdDispatchBase = PFN_vkCmdDispatchBase( device ? vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) : vkGetInstanceProcAddr( instance, "vkCmdDispatchBase" ) ); + vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( device ? vkGetDeviceProcAddr( device, "vkCmdDispatchBaseKHR" ) : vkGetInstanceProcAddr( instance, "vkCmdDispatchBaseKHR" ) ); + vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( device ? vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect" ) : vkGetInstanceProcAddr( instance, "vkCmdDispatchIndirect" ) ); + vkCmdDraw = PFN_vkCmdDraw( device ? vkGetDeviceProcAddr( device, "vkCmdDraw" ) : vkGetInstanceProcAddr( instance, "vkCmdDraw" ) ); + vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( device ? vkGetDeviceProcAddr( device, "vkCmdDrawIndexed" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawIndexed" ) ); + vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( device ? vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirect" ) ); + vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( device ? vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountAMD" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountAMD" ) ); + vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( device ? vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountKHR" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountKHR" ) ); + vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( device ? vkGetDeviceProcAddr( device, "vkCmdDrawIndirect" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawIndirect" ) ); + vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( device ? vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCountEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectByteCountEXT" ) ); + vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( device ? vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountAMD" ) ); + vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( device ? vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountKHR" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountKHR" ) ); + vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( device ? vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountNV" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountNV" ) ); + vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( device ? vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectNV" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectNV" ) ); + vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( device ? vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksNV" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksNV" ) ); + vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( device ? vkGetDeviceProcAddr( device, "vkCmdEndConditionalRenderingEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdEndConditionalRenderingEXT" ) ); + vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( device ? vkGetDeviceProcAddr( device, "vkCmdEndDebugUtilsLabelEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdEndDebugUtilsLabelEXT" ) ); + vkCmdEndQuery = PFN_vkCmdEndQuery( device ? vkGetDeviceProcAddr( device, "vkCmdEndQuery" ) : vkGetInstanceProcAddr( instance, "vkCmdEndQuery" ) ); + vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( device ? vkGetDeviceProcAddr( device, "vkCmdEndQueryIndexedEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdEndQueryIndexedEXT" ) ); + vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( device ? vkGetDeviceProcAddr( device, "vkCmdEndRenderPass" ) : vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass" ) ); + vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( device ? vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2KHR" ) : vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2KHR" ) ); + vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( device ? vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedbackEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdEndTransformFeedbackEXT" ) ); + vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( device ? vkGetDeviceProcAddr( device, "vkCmdExecuteCommands" ) : vkGetInstanceProcAddr( instance, "vkCmdExecuteCommands" ) ); + vkCmdFillBuffer = PFN_vkCmdFillBuffer( device ? vkGetDeviceProcAddr( device, "vkCmdFillBuffer" ) : vkGetInstanceProcAddr( instance, "vkCmdFillBuffer" ) ); + vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( device ? vkGetDeviceProcAddr( device, "vkCmdInsertDebugUtilsLabelEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdInsertDebugUtilsLabelEXT" ) ); + vkCmdNextSubpass = PFN_vkCmdNextSubpass( device ? vkGetDeviceProcAddr( device, "vkCmdNextSubpass" ) : vkGetInstanceProcAddr( instance, "vkCmdNextSubpass" ) ); + vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( device ? vkGetDeviceProcAddr( device, "vkCmdNextSubpass2KHR" ) : vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2KHR" ) ); + vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( device ? vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier" ) : vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier" ) ); + vkCmdProcessCommandsNVX = PFN_vkCmdProcessCommandsNVX( device ? vkGetDeviceProcAddr( device, "vkCmdProcessCommandsNVX" ) : vkGetInstanceProcAddr( instance, "vkCmdProcessCommandsNVX" ) ); + vkCmdPushConstants = PFN_vkCmdPushConstants( device ? vkGetDeviceProcAddr( device, "vkCmdPushConstants" ) : vkGetInstanceProcAddr( instance, "vkCmdPushConstants" ) ); + vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( device ? vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetKHR" ) : vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetKHR" ) ); + vkCmdPushDescriptorSetWithTemplateKHR = PFN_vkCmdPushDescriptorSetWithTemplateKHR( device ? vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplateKHR" ) : vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplateKHR" ) ); + vkCmdReserveSpaceForCommandsNVX = PFN_vkCmdReserveSpaceForCommandsNVX( device ? vkGetDeviceProcAddr( device, "vkCmdReserveSpaceForCommandsNVX" ) : vkGetInstanceProcAddr( instance, "vkCmdReserveSpaceForCommandsNVX" ) ); + vkCmdResetEvent = PFN_vkCmdResetEvent( device ? vkGetDeviceProcAddr( device, "vkCmdResetEvent" ) : vkGetInstanceProcAddr( instance, "vkCmdResetEvent" ) ); + vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( device ? vkGetDeviceProcAddr( device, "vkCmdResetQueryPool" ) : vkGetInstanceProcAddr( instance, "vkCmdResetQueryPool" ) ); + vkCmdResolveImage = PFN_vkCmdResolveImage( device ? vkGetDeviceProcAddr( device, "vkCmdResolveImage" ) : vkGetInstanceProcAddr( instance, "vkCmdResolveImage" ) ); + vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( device ? vkGetDeviceProcAddr( device, "vkCmdSetBlendConstants" ) : vkGetInstanceProcAddr( instance, "vkCmdSetBlendConstants" ) ); + vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( device ? vkGetDeviceProcAddr( device, "vkCmdSetCheckpointNV" ) : vkGetInstanceProcAddr( instance, "vkCmdSetCheckpointNV" ) ); + vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( device ? vkGetDeviceProcAddr( device, "vkCmdSetCoarseSampleOrderNV" ) : vkGetInstanceProcAddr( instance, "vkCmdSetCoarseSampleOrderNV" ) ); + vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( device ? vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) : vkGetInstanceProcAddr( instance, "vkCmdSetDepthBias" ) ); + vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( device ? vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) : vkGetInstanceProcAddr( instance, "vkCmdSetDepthBounds" ) ); + vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( device ? vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) : vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMask" ) ); + vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( device ? vkGetDeviceProcAddr( device, "vkCmdSetDeviceMaskKHR" ) : vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMaskKHR" ) ); + vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( device ? vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEXT" ) ); + vkCmdSetEvent = PFN_vkCmdSetEvent( device ? vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) : vkGetInstanceProcAddr( instance, "vkCmdSetEvent" ) ); + vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( device ? vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) : vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorNV" ) ); + vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( device ? vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) : vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) ); + vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( device ? vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEXT" ) ); + vkCmdSetScissor = PFN_vkCmdSetScissor( device ? vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) : vkGetInstanceProcAddr( instance, "vkCmdSetScissor" ) ); + vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( device ? vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) : vkGetInstanceProcAddr( instance, "vkCmdSetStencilCompareMask" ) ); + vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( device ? vkGetDeviceProcAddr( device, "vkCmdSetStencilReference" ) : vkGetInstanceProcAddr( instance, "vkCmdSetStencilReference" ) ); + vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( device ? vkGetDeviceProcAddr( device, "vkCmdSetStencilWriteMask" ) : vkGetInstanceProcAddr( instance, "vkCmdSetStencilWriteMask" ) ); + vkCmdSetViewport = PFN_vkCmdSetViewport( device ? vkGetDeviceProcAddr( device, "vkCmdSetViewport" ) : vkGetInstanceProcAddr( instance, "vkCmdSetViewport" ) ); + vkCmdSetViewportShadingRatePaletteNV = PFN_vkCmdSetViewportShadingRatePaletteNV( device ? vkGetDeviceProcAddr( device, "vkCmdSetViewportShadingRatePaletteNV" ) : vkGetInstanceProcAddr( instance, "vkCmdSetViewportShadingRatePaletteNV" ) ); + vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( device ? vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingNV" ) : vkGetInstanceProcAddr( instance, "vkCmdSetViewportWScalingNV" ) ); + vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( device ? vkGetDeviceProcAddr( device, "vkCmdTraceRaysNV" ) : vkGetInstanceProcAddr( instance, "vkCmdTraceRaysNV" ) ); + vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( device ? vkGetDeviceProcAddr( device, "vkCmdUpdateBuffer" ) : vkGetInstanceProcAddr( instance, "vkCmdUpdateBuffer" ) ); + vkCmdWaitEvents = PFN_vkCmdWaitEvents( device ? vkGetDeviceProcAddr( device, "vkCmdWaitEvents" ) : vkGetInstanceProcAddr( instance, "vkCmdWaitEvents" ) ); + vkCmdWriteAccelerationStructuresPropertiesNV = PFN_vkCmdWriteAccelerationStructuresPropertiesNV( device ? vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesNV" ) : vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesNV" ) ); + vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( device ? vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarkerAMD" ) : vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarkerAMD" ) ); + vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( device ? vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) : vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp" ) ); + vkEndCommandBuffer = PFN_vkEndCommandBuffer( device ? vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) : vkGetInstanceProcAddr( instance, "vkEndCommandBuffer" ) ); + vkResetCommandBuffer = PFN_vkResetCommandBuffer( device ? vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) : vkGetInstanceProcAddr( instance, "vkResetCommandBuffer" ) ); + vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( device ? vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) : vkGetInstanceProcAddr( instance, "vkAcquireNextImage2KHR" ) ); + vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( device ? vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) : vkGetInstanceProcAddr( instance, "vkAcquireNextImageKHR" ) ); + vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( device ? vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) : vkGetInstanceProcAddr( instance, "vkAllocateCommandBuffers" ) ); + vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( device ? vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) : vkGetInstanceProcAddr( instance, "vkAllocateDescriptorSets" ) ); + vkAllocateMemory = PFN_vkAllocateMemory( device ? vkGetDeviceProcAddr( device, "vkAllocateMemory" ) : vkGetInstanceProcAddr( instance, "vkAllocateMemory" ) ); + vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( device ? vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryNV" ) : vkGetInstanceProcAddr( instance, "vkBindAccelerationStructureMemoryNV" ) ); + vkBindBufferMemory = PFN_vkBindBufferMemory( device ? vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) : vkGetInstanceProcAddr( instance, "vkBindBufferMemory" ) ); + vkBindBufferMemory2 = PFN_vkBindBufferMemory2( device ? vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) : vkGetInstanceProcAddr( instance, "vkBindBufferMemory2" ) ); + vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( device ? vkGetDeviceProcAddr( device, "vkBindBufferMemory2KHR" ) : vkGetInstanceProcAddr( instance, "vkBindBufferMemory2KHR" ) ); + vkBindImageMemory = PFN_vkBindImageMemory( device ? vkGetDeviceProcAddr( device, "vkBindImageMemory" ) : vkGetInstanceProcAddr( instance, "vkBindImageMemory" ) ); + vkBindImageMemory2 = PFN_vkBindImageMemory2( device ? vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) : vkGetInstanceProcAddr( instance, "vkBindImageMemory2" ) ); + vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( device ? vkGetDeviceProcAddr( device, "vkBindImageMemory2KHR" ) : vkGetInstanceProcAddr( instance, "vkBindImageMemory2KHR" ) ); + vkCompileDeferredNV = PFN_vkCompileDeferredNV( device ? vkGetDeviceProcAddr( device, "vkCompileDeferredNV" ) : vkGetInstanceProcAddr( instance, "vkCompileDeferredNV" ) ); + vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( device ? vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureNV" ) : vkGetInstanceProcAddr( instance, "vkCreateAccelerationStructureNV" ) ); + vkCreateBuffer = PFN_vkCreateBuffer( device ? vkGetDeviceProcAddr( device, "vkCreateBuffer" ) : vkGetInstanceProcAddr( instance, "vkCreateBuffer" ) ); + vkCreateBufferView = PFN_vkCreateBufferView( device ? vkGetDeviceProcAddr( device, "vkCreateBufferView" ) : vkGetInstanceProcAddr( instance, "vkCreateBufferView" ) ); + vkCreateCommandPool = PFN_vkCreateCommandPool( device ? vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) : vkGetInstanceProcAddr( instance, "vkCreateCommandPool" ) ); + vkCreateComputePipelines = PFN_vkCreateComputePipelines( device ? vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) : vkGetInstanceProcAddr( instance, "vkCreateComputePipelines" ) ); + vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( device ? vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) : vkGetInstanceProcAddr( instance, "vkCreateDescriptorPool" ) ); + vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( device ? vkGetDeviceProcAddr( device, "vkCreateDescriptorSetLayout" ) : vkGetInstanceProcAddr( instance, "vkCreateDescriptorSetLayout" ) ); + vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( device ? vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplate" ) : vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplate" ) ); + vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( device ? vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplateKHR" ) : vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplateKHR" ) ); + vkCreateEvent = PFN_vkCreateEvent( device ? vkGetDeviceProcAddr( device, "vkCreateEvent" ) : vkGetInstanceProcAddr( instance, "vkCreateEvent" ) ); + vkCreateFence = PFN_vkCreateFence( device ? vkGetDeviceProcAddr( device, "vkCreateFence" ) : vkGetInstanceProcAddr( instance, "vkCreateFence" ) ); + vkCreateFramebuffer = PFN_vkCreateFramebuffer( device ? vkGetDeviceProcAddr( device, "vkCreateFramebuffer" ) : vkGetInstanceProcAddr( instance, "vkCreateFramebuffer" ) ); + vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( device ? vkGetDeviceProcAddr( device, "vkCreateGraphicsPipelines" ) : vkGetInstanceProcAddr( instance, "vkCreateGraphicsPipelines" ) ); + vkCreateImage = PFN_vkCreateImage( device ? vkGetDeviceProcAddr( device, "vkCreateImage" ) : vkGetInstanceProcAddr( instance, "vkCreateImage" ) ); + vkCreateImageView = PFN_vkCreateImageView( device ? vkGetDeviceProcAddr( device, "vkCreateImageView" ) : vkGetInstanceProcAddr( instance, "vkCreateImageView" ) ); + vkCreateIndirectCommandsLayoutNVX = PFN_vkCreateIndirectCommandsLayoutNVX( device ? vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutNVX" ) : vkGetInstanceProcAddr( instance, "vkCreateIndirectCommandsLayoutNVX" ) ); + vkCreateObjectTableNVX = PFN_vkCreateObjectTableNVX( device ? vkGetDeviceProcAddr( device, "vkCreateObjectTableNVX" ) : vkGetInstanceProcAddr( instance, "vkCreateObjectTableNVX" ) ); + vkCreatePipelineCache = PFN_vkCreatePipelineCache( device ? vkGetDeviceProcAddr( device, "vkCreatePipelineCache" ) : vkGetInstanceProcAddr( instance, "vkCreatePipelineCache" ) ); + vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( device ? vkGetDeviceProcAddr( device, "vkCreatePipelineLayout" ) : vkGetInstanceProcAddr( instance, "vkCreatePipelineLayout" ) ); + vkCreateQueryPool = PFN_vkCreateQueryPool( device ? vkGetDeviceProcAddr( device, "vkCreateQueryPool" ) : vkGetInstanceProcAddr( instance, "vkCreateQueryPool" ) ); + vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( device ? vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesNV" ) : vkGetInstanceProcAddr( instance, "vkCreateRayTracingPipelinesNV" ) ); + vkCreateRenderPass = PFN_vkCreateRenderPass( device ? vkGetDeviceProcAddr( device, "vkCreateRenderPass" ) : vkGetInstanceProcAddr( instance, "vkCreateRenderPass" ) ); + vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( device ? vkGetDeviceProcAddr( device, "vkCreateRenderPass2KHR" ) : vkGetInstanceProcAddr( instance, "vkCreateRenderPass2KHR" ) ); + vkCreateSampler = PFN_vkCreateSampler( device ? vkGetDeviceProcAddr( device, "vkCreateSampler" ) : vkGetInstanceProcAddr( instance, "vkCreateSampler" ) ); + vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( device ? vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) : vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversion" ) ); + vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( device ? vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversionKHR" ) : vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversionKHR" ) ); + vkCreateSemaphore = PFN_vkCreateSemaphore( device ? vkGetDeviceProcAddr( device, "vkCreateSemaphore" ) : vkGetInstanceProcAddr( instance, "vkCreateSemaphore" ) ); + vkCreateShaderModule = PFN_vkCreateShaderModule( device ? vkGetDeviceProcAddr( device, "vkCreateShaderModule" ) : vkGetInstanceProcAddr( instance, "vkCreateShaderModule" ) ); + vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( device ? vkGetDeviceProcAddr( device, "vkCreateSharedSwapchainsKHR" ) : vkGetInstanceProcAddr( instance, "vkCreateSharedSwapchainsKHR" ) ); + vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( device ? vkGetDeviceProcAddr( device, "vkCreateSwapchainKHR" ) : vkGetInstanceProcAddr( instance, "vkCreateSwapchainKHR" ) ); + vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( device ? vkGetDeviceProcAddr( device, "vkCreateValidationCacheEXT" ) : vkGetInstanceProcAddr( instance, "vkCreateValidationCacheEXT" ) ); + vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( device ? vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectNameEXT" ) : vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectNameEXT" ) ); + vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( device ? vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectTagEXT" ) : vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectTagEXT" ) ); + vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( device ? vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureNV" ) : vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureNV" ) ); + vkDestroyBuffer = PFN_vkDestroyBuffer( device ? vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) : vkGetInstanceProcAddr( instance, "vkDestroyBuffer" ) ); + vkDestroyBufferView = PFN_vkDestroyBufferView( device ? vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) : vkGetInstanceProcAddr( instance, "vkDestroyBufferView" ) ); + vkDestroyCommandPool = PFN_vkDestroyCommandPool( device ? vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) : vkGetInstanceProcAddr( instance, "vkDestroyCommandPool" ) ); + vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( device ? vkGetDeviceProcAddr( device, "vkDestroyDescriptorPool" ) : vkGetInstanceProcAddr( instance, "vkDestroyDescriptorPool" ) ); + vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( device ? vkGetDeviceProcAddr( device, "vkDestroyDescriptorSetLayout" ) : vkGetInstanceProcAddr( instance, "vkDestroyDescriptorSetLayout" ) ); + vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( device ? vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplate" ) : vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplate" ) ); + vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplateKHR( device ? vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplateKHR" ) : vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplateKHR" ) ); + vkDestroyDevice = PFN_vkDestroyDevice( device ? vkGetDeviceProcAddr( device, "vkDestroyDevice" ) : vkGetInstanceProcAddr( instance, "vkDestroyDevice" ) ); + vkDestroyEvent = PFN_vkDestroyEvent( device ? vkGetDeviceProcAddr( device, "vkDestroyEvent" ) : vkGetInstanceProcAddr( instance, "vkDestroyEvent" ) ); + vkDestroyFence = PFN_vkDestroyFence( device ? vkGetDeviceProcAddr( device, "vkDestroyFence" ) : vkGetInstanceProcAddr( instance, "vkDestroyFence" ) ); + vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( device ? vkGetDeviceProcAddr( device, "vkDestroyFramebuffer" ) : vkGetInstanceProcAddr( instance, "vkDestroyFramebuffer" ) ); + vkDestroyImage = PFN_vkDestroyImage( device ? vkGetDeviceProcAddr( device, "vkDestroyImage" ) : vkGetInstanceProcAddr( instance, "vkDestroyImage" ) ); + vkDestroyImageView = PFN_vkDestroyImageView( device ? vkGetDeviceProcAddr( device, "vkDestroyImageView" ) : vkGetInstanceProcAddr( instance, "vkDestroyImageView" ) ); + vkDestroyIndirectCommandsLayoutNVX = PFN_vkDestroyIndirectCommandsLayoutNVX( device ? vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutNVX" ) : vkGetInstanceProcAddr( instance, "vkDestroyIndirectCommandsLayoutNVX" ) ); + vkDestroyObjectTableNVX = PFN_vkDestroyObjectTableNVX( device ? vkGetDeviceProcAddr( device, "vkDestroyObjectTableNVX" ) : vkGetInstanceProcAddr( instance, "vkDestroyObjectTableNVX" ) ); + vkDestroyPipeline = PFN_vkDestroyPipeline( device ? vkGetDeviceProcAddr( device, "vkDestroyPipeline" ) : vkGetInstanceProcAddr( instance, "vkDestroyPipeline" ) ); + vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( device ? vkGetDeviceProcAddr( device, "vkDestroyPipelineCache" ) : vkGetInstanceProcAddr( instance, "vkDestroyPipelineCache" ) ); + vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( device ? vkGetDeviceProcAddr( device, "vkDestroyPipelineLayout" ) : vkGetInstanceProcAddr( instance, "vkDestroyPipelineLayout" ) ); + vkDestroyQueryPool = PFN_vkDestroyQueryPool( device ? vkGetDeviceProcAddr( device, "vkDestroyQueryPool" ) : vkGetInstanceProcAddr( instance, "vkDestroyQueryPool" ) ); + vkDestroyRenderPass = PFN_vkDestroyRenderPass( device ? vkGetDeviceProcAddr( device, "vkDestroyRenderPass" ) : vkGetInstanceProcAddr( instance, "vkDestroyRenderPass" ) ); + vkDestroySampler = PFN_vkDestroySampler( device ? vkGetDeviceProcAddr( device, "vkDestroySampler" ) : vkGetInstanceProcAddr( instance, "vkDestroySampler" ) ); + vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( device ? vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) : vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversion" ) ); + vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( device ? vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversionKHR" ) : vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversionKHR" ) ); + vkDestroySemaphore = PFN_vkDestroySemaphore( device ? vkGetDeviceProcAddr( device, "vkDestroySemaphore" ) : vkGetInstanceProcAddr( instance, "vkDestroySemaphore" ) ); + vkDestroyShaderModule = PFN_vkDestroyShaderModule( device ? vkGetDeviceProcAddr( device, "vkDestroyShaderModule" ) : vkGetInstanceProcAddr( instance, "vkDestroyShaderModule" ) ); + vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( device ? vkGetDeviceProcAddr( device, "vkDestroySwapchainKHR" ) : vkGetInstanceProcAddr( instance, "vkDestroySwapchainKHR" ) ); + vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( device ? vkGetDeviceProcAddr( device, "vkDestroyValidationCacheEXT" ) : vkGetInstanceProcAddr( instance, "vkDestroyValidationCacheEXT" ) ); + vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( device ? vkGetDeviceProcAddr( device, "vkDeviceWaitIdle" ) : vkGetInstanceProcAddr( instance, "vkDeviceWaitIdle" ) ); + vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( device ? vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) : vkGetInstanceProcAddr( instance, "vkDisplayPowerControlEXT" ) ); + vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( device ? vkGetDeviceProcAddr( device, "vkFlushMappedMemoryRanges" ) : vkGetInstanceProcAddr( instance, "vkFlushMappedMemoryRanges" ) ); + vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( device ? vkGetDeviceProcAddr( device, "vkFreeCommandBuffers" ) : vkGetInstanceProcAddr( instance, "vkFreeCommandBuffers" ) ); + vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( device ? vkGetDeviceProcAddr( device, "vkFreeDescriptorSets" ) : vkGetInstanceProcAddr( instance, "vkFreeDescriptorSets" ) ); + vkFreeMemory = PFN_vkFreeMemory( device ? vkGetDeviceProcAddr( device, "vkFreeMemory" ) : vkGetInstanceProcAddr( instance, "vkFreeMemory" ) ); + vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( device ? vkGetDeviceProcAddr( device, "vkGetAccelerationStructureHandleNV" ) : vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureHandleNV" ) ); + vkGetAccelerationStructureMemoryRequirementsNV = PFN_vkGetAccelerationStructureMemoryRequirementsNV( device ? vkGetDeviceProcAddr( device, "vkGetAccelerationStructureMemoryRequirementsNV" ) : vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureMemoryRequirementsNV" ) ); +#ifdef VK_USE_PLATFORM_ANDROID_KHR + vkGetAndroidHardwareBufferPropertiesANDROID = PFN_vkGetAndroidHardwareBufferPropertiesANDROID( device ? vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ) : vkGetInstanceProcAddr( instance, "vkGetAndroidHardwareBufferPropertiesANDROID" ) ); +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( device ? vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) : vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressEXT" ) ); + vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( device ? vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements" ) : vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements" ) ); + vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( device ? vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) : vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2" ) ); + vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( device ? vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2KHR" ) : vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2KHR" ) ); + vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( device ? vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) : vkGetInstanceProcAddr( instance, "vkGetCalibratedTimestampsEXT" ) ); + vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( device ? vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) : vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupport" ) ); + vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( device ? vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupportKHR" ) : vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupportKHR" ) ); + vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeatures" ) ); + vkGetDeviceGroupPeerMemoryFeaturesKHR = PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) ); + vkGetDeviceGroupPresentCapabilitiesKHR = PFN_vkGetDeviceGroupPresentCapabilitiesKHR( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPresentCapabilitiesKHR" ) ); + vkGetDeviceGroupSurfacePresentModesKHR = PFN_vkGetDeviceGroupSurfacePresentModesKHR( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModesKHR" ) ); + vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( device ? vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryCommitment" ) ); + vkGetDeviceQueue = PFN_vkGetDeviceQueue( device ? vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceQueue" ) ); + vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( device ? vkGetDeviceProcAddr( device, "vkGetDeviceQueue2" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceQueue2" ) ); + vkGetEventStatus = PFN_vkGetEventStatus( device ? vkGetDeviceProcAddr( device, "vkGetEventStatus" ) : vkGetInstanceProcAddr( instance, "vkGetEventStatus" ) ); + vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( device ? vkGetDeviceProcAddr( device, "vkGetFenceFdKHR" ) : vkGetInstanceProcAddr( instance, "vkGetFenceFdKHR" ) ); + vkGetFenceStatus = PFN_vkGetFenceStatus( device ? vkGetDeviceProcAddr( device, "vkGetFenceStatus" ) : vkGetInstanceProcAddr( instance, "vkGetFenceStatus" ) ); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( device ? vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ) : vkGetInstanceProcAddr( instance, "vkGetFenceWin32HandleKHR" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + vkGetImageDrmFormatModifierPropertiesEXT = PFN_vkGetImageDrmFormatModifierPropertiesEXT( device ? vkGetDeviceProcAddr( device, "vkGetImageDrmFormatModifierPropertiesEXT" ) : vkGetInstanceProcAddr( instance, "vkGetImageDrmFormatModifierPropertiesEXT" ) ); + vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( device ? vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements" ) : vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements" ) ); + vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( device ? vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) : vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2" ) ); + vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( device ? vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2KHR" ) : vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2KHR" ) ); + vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( device ? vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements" ) : vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements" ) ); + vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( device ? vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) : vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2" ) ); + vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2KHR( device ? vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2KHR" ) : vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2KHR" ) ); + vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( device ? vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) : vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout" ) ); +#ifdef VK_USE_PLATFORM_ANDROID_KHR + vkGetMemoryAndroidHardwareBufferANDROID = PFN_vkGetMemoryAndroidHardwareBufferANDROID( device ? vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) : vkGetInstanceProcAddr( instance, "vkGetMemoryAndroidHardwareBufferANDROID" ) ); +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( device ? vkGetDeviceProcAddr( device, "vkGetMemoryFdKHR" ) : vkGetInstanceProcAddr( instance, "vkGetMemoryFdKHR" ) ); + vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( device ? vkGetDeviceProcAddr( device, "vkGetMemoryFdPropertiesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetMemoryFdPropertiesKHR" ) ); + vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( device ? vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) : vkGetInstanceProcAddr( instance, "vkGetMemoryHostPointerPropertiesEXT" ) ); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( device ? vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ) : vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleKHR" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( device ? vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ) : vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleNV" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( device ? vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandlePropertiesKHR" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( device ? vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) : vkGetInstanceProcAddr( instance, "vkGetPastPresentationTimingGOOGLE" ) ); + vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( device ? vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) : vkGetInstanceProcAddr( instance, "vkGetPipelineCacheData" ) ); + vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( device ? vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) : vkGetInstanceProcAddr( instance, "vkGetQueryPoolResults" ) ); + vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( device ? vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) : vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesNV" ) ); + vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( device ? vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) : vkGetInstanceProcAddr( instance, "vkGetRefreshCycleDurationGOOGLE" ) ); + vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( device ? vkGetDeviceProcAddr( device, "vkGetRenderAreaGranularity" ) : vkGetInstanceProcAddr( instance, "vkGetRenderAreaGranularity" ) ); + vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( device ? vkGetDeviceProcAddr( device, "vkGetSemaphoreFdKHR" ) : vkGetInstanceProcAddr( instance, "vkGetSemaphoreFdKHR" ) ); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( device ? vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ) : vkGetInstanceProcAddr( instance, "vkGetSemaphoreWin32HandleKHR" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( device ? vkGetDeviceProcAddr( device, "vkGetShaderInfoAMD" ) : vkGetInstanceProcAddr( instance, "vkGetShaderInfoAMD" ) ); + vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( device ? vkGetDeviceProcAddr( device, "vkGetSwapchainCounterEXT" ) : vkGetInstanceProcAddr( instance, "vkGetSwapchainCounterEXT" ) ); + vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( device ? vkGetDeviceProcAddr( device, "vkGetSwapchainImagesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetSwapchainImagesKHR" ) ); + vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( device ? vkGetDeviceProcAddr( device, "vkGetSwapchainStatusKHR" ) : vkGetInstanceProcAddr( instance, "vkGetSwapchainStatusKHR" ) ); + vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( device ? vkGetDeviceProcAddr( device, "vkGetValidationCacheDataEXT" ) : vkGetInstanceProcAddr( instance, "vkGetValidationCacheDataEXT" ) ); + vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( device ? vkGetDeviceProcAddr( device, "vkImportFenceFdKHR" ) : vkGetInstanceProcAddr( instance, "vkImportFenceFdKHR" ) ); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( device ? vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ) : vkGetInstanceProcAddr( instance, "vkImportFenceWin32HandleKHR" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( device ? vkGetDeviceProcAddr( device, "vkImportSemaphoreFdKHR" ) : vkGetInstanceProcAddr( instance, "vkImportSemaphoreFdKHR" ) ); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( device ? vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ) : vkGetInstanceProcAddr( instance, "vkImportSemaphoreWin32HandleKHR" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( device ? vkGetDeviceProcAddr( device, "vkInvalidateMappedMemoryRanges" ) : vkGetInstanceProcAddr( instance, "vkInvalidateMappedMemoryRanges" ) ); + vkMapMemory = PFN_vkMapMemory( device ? vkGetDeviceProcAddr( device, "vkMapMemory" ) : vkGetInstanceProcAddr( instance, "vkMapMemory" ) ); + vkMergePipelineCaches = PFN_vkMergePipelineCaches( device ? vkGetDeviceProcAddr( device, "vkMergePipelineCaches" ) : vkGetInstanceProcAddr( instance, "vkMergePipelineCaches" ) ); + vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( device ? vkGetDeviceProcAddr( device, "vkMergeValidationCachesEXT" ) : vkGetInstanceProcAddr( instance, "vkMergeValidationCachesEXT" ) ); + vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( device ? vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) : vkGetInstanceProcAddr( instance, "vkRegisterDeviceEventEXT" ) ); + vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( device ? vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) : vkGetInstanceProcAddr( instance, "vkRegisterDisplayEventEXT" ) ); + vkRegisterObjectsNVX = PFN_vkRegisterObjectsNVX( device ? vkGetDeviceProcAddr( device, "vkRegisterObjectsNVX" ) : vkGetInstanceProcAddr( instance, "vkRegisterObjectsNVX" ) ); + vkResetCommandPool = PFN_vkResetCommandPool( device ? vkGetDeviceProcAddr( device, "vkResetCommandPool" ) : vkGetInstanceProcAddr( instance, "vkResetCommandPool" ) ); + vkResetDescriptorPool = PFN_vkResetDescriptorPool( device ? vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) : vkGetInstanceProcAddr( instance, "vkResetDescriptorPool" ) ); + vkResetEvent = PFN_vkResetEvent( device ? vkGetDeviceProcAddr( device, "vkResetEvent" ) : vkGetInstanceProcAddr( instance, "vkResetEvent" ) ); + vkResetFences = PFN_vkResetFences( device ? vkGetDeviceProcAddr( device, "vkResetFences" ) : vkGetInstanceProcAddr( instance, "vkResetFences" ) ); + vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( device ? vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) : vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectNameEXT" ) ); + vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( device ? vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) : vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectTagEXT" ) ); + vkSetEvent = PFN_vkSetEvent( device ? vkGetDeviceProcAddr( device, "vkSetEvent" ) : vkGetInstanceProcAddr( instance, "vkSetEvent" ) ); + vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( device ? vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) : vkGetInstanceProcAddr( instance, "vkSetHdrMetadataEXT" ) ); + vkTrimCommandPool = PFN_vkTrimCommandPool( device ? vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) : vkGetInstanceProcAddr( instance, "vkTrimCommandPool" ) ); + vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( device ? vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) : vkGetInstanceProcAddr( instance, "vkTrimCommandPoolKHR" ) ); + vkUnmapMemory = PFN_vkUnmapMemory( device ? vkGetDeviceProcAddr( device, "vkUnmapMemory" ) : vkGetInstanceProcAddr( instance, "vkUnmapMemory" ) ); + vkUnregisterObjectsNVX = PFN_vkUnregisterObjectsNVX( device ? vkGetDeviceProcAddr( device, "vkUnregisterObjectsNVX" ) : vkGetInstanceProcAddr( instance, "vkUnregisterObjectsNVX" ) ); + vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( device ? vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) : vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplate" ) ); + vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR( device ? vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplateKHR" ) : vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplateKHR" ) ); + vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( device ? vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) : vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSets" ) ); + vkWaitForFences = PFN_vkWaitForFences( device ? vkGetDeviceProcAddr( device, "vkWaitForFences" ) : vkGetInstanceProcAddr( instance, "vkWaitForFences" ) ); +#ifdef VK_USE_PLATFORM_ANDROID_KHR + vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) ); +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugReportCallbackEXT" ) ); + vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugUtilsMessengerEXT" ) ); + vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayPlaneSurfaceKHR" ) ); +#ifdef VK_USE_PLATFORM_IOS_MVK + vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ) ); +#endif /*VK_USE_PLATFORM_IOS_MVK*/ +#ifdef VK_USE_PLATFORM_FUCHSIA + vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateImagePipeSurfaceFUCHSIA" ) ); +#endif /*VK_USE_PLATFORM_FUCHSIA*/ +#ifdef VK_USE_PLATFORM_MACOS_MVK + vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateMacOSSurfaceMVK" ) ); +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ +#ifdef VK_USE_PLATFORM_VI_NN + vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN( vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ) ); +#endif /*VK_USE_PLATFORM_VI_NN*/ +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWaylandSurfaceKHR" ) ); +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWin32SurfaceKHR" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_XCB_KHR + vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXcbSurfaceKHR" ) ); +#endif /*VK_USE_PLATFORM_XCB_KHR*/ +#ifdef VK_USE_PLATFORM_XLIB_KHR + vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXlibSurfaceKHR" ) ); +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT( vkGetInstanceProcAddr( instance, "vkDebugReportMessageEXT" ) ); + vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugReportCallbackEXT" ) ); + vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugUtilsMessengerEXT" ) ); + vkDestroyInstance = PFN_vkDestroyInstance( vkGetInstanceProcAddr( instance, "vkDestroyInstance" ) ); + vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR( vkGetInstanceProcAddr( instance, "vkDestroySurfaceKHR" ) ); + vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroups" ) ); + vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroupsKHR" ) ); + vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDevices" ) ); + vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) ); +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) ); +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + vkCreateDevice = PFN_vkCreateDevice( vkGetInstanceProcAddr( instance, "vkCreateDevice" ) ); + vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) ); + vkEnumerateDeviceExtensionProperties = PFN_vkEnumerateDeviceExtensionProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceExtensionProperties" ) ); + vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceLayerProperties" ) ); + vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModeProperties2KHR" ) ); + vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModePropertiesKHR" ) ); + vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilities2KHR" ) ); + vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilitiesKHR" ) ); + vkGetDisplayPlaneSupportedDisplaysKHR = PFN_vkGetDisplayPlaneSupportedDisplaysKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneSupportedDisplaysKHR" ) ); + vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) ); + vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV" ) ); + vkGetPhysicalDeviceDisplayPlaneProperties2KHR = PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR" ) ); + vkGetPhysicalDeviceDisplayPlanePropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR" ) ); + vkGetPhysicalDeviceDisplayProperties2KHR = PFN_vkGetPhysicalDeviceDisplayProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayProperties2KHR" ) ); + vkGetPhysicalDeviceDisplayPropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPropertiesKHR" ) ); + vkGetPhysicalDeviceExternalBufferProperties = PFN_vkGetPhysicalDeviceExternalBufferProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferProperties" ) ); + vkGetPhysicalDeviceExternalBufferPropertiesKHR = PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR" ) ); + vkGetPhysicalDeviceExternalFenceProperties = PFN_vkGetPhysicalDeviceExternalFenceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFenceProperties" ) ); + vkGetPhysicalDeviceExternalFencePropertiesKHR = PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR" ) ); + vkGetPhysicalDeviceExternalImageFormatPropertiesNV = PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV" ) ); + vkGetPhysicalDeviceExternalSemaphoreProperties = PFN_vkGetPhysicalDeviceExternalSemaphoreProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphoreProperties" ) ); + vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR" ) ); + vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures" ) ); + vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2" ) ); + vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2KHR" ) ); + vkGetPhysicalDeviceFormatProperties = PFN_vkGetPhysicalDeviceFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties" ) ); + vkGetPhysicalDeviceFormatProperties2 = PFN_vkGetPhysicalDeviceFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2" ) ); + vkGetPhysicalDeviceFormatProperties2KHR = PFN_vkGetPhysicalDeviceFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2KHR" ) ); + vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX = PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX" ) ); + vkGetPhysicalDeviceImageFormatProperties = PFN_vkGetPhysicalDeviceImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties" ) ); + vkGetPhysicalDeviceImageFormatProperties2 = PFN_vkGetPhysicalDeviceImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2" ) ); + vkGetPhysicalDeviceImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2KHR" ) ); + vkGetPhysicalDeviceMemoryProperties = PFN_vkGetPhysicalDeviceMemoryProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties" ) ); + vkGetPhysicalDeviceMemoryProperties2 = PFN_vkGetPhysicalDeviceMemoryProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2" ) ); + vkGetPhysicalDeviceMemoryProperties2KHR = PFN_vkGetPhysicalDeviceMemoryProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2KHR" ) ); + vkGetPhysicalDeviceMultisamplePropertiesEXT = PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT" ) ); + vkGetPhysicalDevicePresentRectanglesKHR = PFN_vkGetPhysicalDevicePresentRectanglesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDevicePresentRectanglesKHR" ) ); + vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties" ) ); + vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) ); + vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2KHR" ) ); + vkGetPhysicalDeviceQueueFamilyProperties = PFN_vkGetPhysicalDeviceQueueFamilyProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties" ) ); + vkGetPhysicalDeviceQueueFamilyProperties2 = PFN_vkGetPhysicalDeviceQueueFamilyProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) ); + vkGetPhysicalDeviceQueueFamilyProperties2KHR = PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR" ) ); + vkGetPhysicalDeviceSparseImageFormatProperties = PFN_vkGetPhysicalDeviceSparseImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties" ) ); + vkGetPhysicalDeviceSparseImageFormatProperties2 = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2" ) ); + vkGetPhysicalDeviceSparseImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR" ) ); + vkGetPhysicalDeviceSurfaceCapabilities2EXT = PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT" ) ); + vkGetPhysicalDeviceSurfaceCapabilities2KHR = PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR" ) ); + vkGetPhysicalDeviceSurfaceCapabilitiesKHR = PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR" ) ); + vkGetPhysicalDeviceSurfaceFormats2KHR = PFN_vkGetPhysicalDeviceSurfaceFormats2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormats2KHR" ) ); + vkGetPhysicalDeviceSurfaceFormatsKHR = PFN_vkGetPhysicalDeviceSurfaceFormatsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormatsKHR" ) ); + vkGetPhysicalDeviceSurfacePresentModesKHR = PFN_vkGetPhysicalDeviceSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModesKHR" ) ); + vkGetPhysicalDeviceSurfaceSupportKHR = PFN_vkGetPhysicalDeviceSurfaceSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceSupportKHR" ) ); +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + vkGetPhysicalDeviceWaylandPresentationSupportKHR = PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR" ) ); +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkGetPhysicalDeviceWin32PresentationSupportKHR = PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_XCB_KHR + vkGetPhysicalDeviceXcbPresentationSupportKHR = PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR" ) ); +#endif /*VK_USE_PLATFORM_XCB_KHR*/ +#ifdef VK_USE_PLATFORM_XLIB_KHR + vkGetPhysicalDeviceXlibPresentationSupportKHR = PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR" ) ); +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) ); +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) ); + vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( device ? vkGetDeviceProcAddr( device, "vkGetQueueCheckpointDataNV" ) : vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointDataNV" ) ); + vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( device ? vkGetDeviceProcAddr( device, "vkQueueBeginDebugUtilsLabelEXT" ) : vkGetInstanceProcAddr( instance, "vkQueueBeginDebugUtilsLabelEXT" ) ); + vkQueueBindSparse = PFN_vkQueueBindSparse( device ? vkGetDeviceProcAddr( device, "vkQueueBindSparse" ) : vkGetInstanceProcAddr( instance, "vkQueueBindSparse" ) ); + vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( device ? vkGetDeviceProcAddr( device, "vkQueueEndDebugUtilsLabelEXT" ) : vkGetInstanceProcAddr( instance, "vkQueueEndDebugUtilsLabelEXT" ) ); + vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( device ? vkGetDeviceProcAddr( device, "vkQueueInsertDebugUtilsLabelEXT" ) : vkGetInstanceProcAddr( instance, "vkQueueInsertDebugUtilsLabelEXT" ) ); + vkQueuePresentKHR = PFN_vkQueuePresentKHR( device ? vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) : vkGetInstanceProcAddr( instance, "vkQueuePresentKHR" ) ); + vkQueueSubmit = PFN_vkQueueSubmit( device ? vkGetDeviceProcAddr( device, "vkQueueSubmit" ) : vkGetInstanceProcAddr( instance, "vkQueueSubmit" ) ); + vkQueueWaitIdle = PFN_vkQueueWaitIdle( device ? vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) : vkGetInstanceProcAddr( instance, "vkQueueWaitIdle" ) ); + } + }; +} // namespace VULKAN_HPP_NAMESPACE +#endif diff --git a/moltenvk/include/vulkan/vulkan_android.h b/moltenvk/include/vulkan/vulkan_android.h new file mode 100644 index 00000000..e70376c8 --- /dev/null +++ b/moltenvk/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-2019 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/moltenvk/include/vulkan/vulkan_core.h b/moltenvk/include/vulkan/vulkan_core.h new file mode 100644 index 00000000..515a73e4 --- /dev/null +++ b/moltenvk/include/vulkan/vulkan_core.h @@ -0,0 +1,9229 @@ +#ifndef VULKAN_CORE_H_ +#define VULKAN_CORE_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2019 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 101 + + +#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_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, + VK_ERROR_FRAGMENTATION_EXT = -1000161000, + VK_ERROR_NOT_PERMITTED_EXT = -1000174001, + VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = -1000244000, + 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_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_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002, + VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000, + 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_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, + 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_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001, + VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = 1000082000, + 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_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001, + VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = 1000109000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = 1000109001, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = 1000109002, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = 1000109003, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = 1000109004, + VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = 1000109005, + VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = 1000109006, + 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_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = 1000138000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = 1000138001, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = 1000138002, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = 1000138003, + 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_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000, + VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005, + 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_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005, + VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001, + VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003, + VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004, + VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005, + VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009, + VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000, + VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000, + VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = 1000177000, + 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_ATOMIC_INT64_FEATURES_KHR = 1000180000, + VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000, + 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_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = 1000196000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = 1000197000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = 1000199000, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = 1000199001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = 1000203000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002, + VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = 1000211000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000, + VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001, + VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = 1000221000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000, + VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = 1000244000, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = 1000244001, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002, + VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = 1000246000, + VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000, + VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002, + VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, + 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_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, + 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_DRM_FORMAT_MODIFIER_EXT = 1000158000, + 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_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, + 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_SHADING_RATE_OPTIMAL_NV = 1000164003, + VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000, + 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_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004, + VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006, + VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001, + 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_CUBIC_EXT = VK_FILTER_CUBIC_IMG, + 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_INLINE_UNIFORM_BLOCK_EXT = 1000138000, + VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, + 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_RAY_TRACING_NV = 1000165000, + 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_NONE_NV = 1000165000, + 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_ACCELERATION_STRUCTURE_NV = 1000165000, + 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_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000, + 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_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG, + 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_SHADING_RATE_IMAGE_BIT_NV = 0x00000100, + VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200, + 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_CORNER_SAMPLED_BIT_NV = 0x00002000, + VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, + VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000, + 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_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000, + VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000, + VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000, + VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00400000, + VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = 0x00200000, + VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000, + VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000, + VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000, + VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000, + 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_MEMORY_PLANE_0_BIT_EXT = 0x00000080, + VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100, + VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200, + VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400, + 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_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 0x00000010, + 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_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800, + VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000, + VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200, + VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = 0x00000400, + VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = 0x00020000, + VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkBufferUsageFlagBits; +typedef VkFlags VkBufferUsageFlags; +typedef VkFlags VkBufferViewCreateFlags; + +typedef enum VkImageViewCreateFlagBits { + VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001, + VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageViewCreateFlagBits; +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_DEFER_COMPILE_BIT_NV = 0x00000020, + 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_RAYGEN_BIT_NV = 0x00000100, + VK_SHADER_STAGE_ANY_HIT_BIT_NV = 0x00000200, + VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = 0x00000400, + VK_SHADER_STAGE_MISS_BIT_NV = 0x00000800, + VK_SHADER_STAGE_INTERSECTION_BIT_NV = 0x00001000, + VK_SHADER_STAGE_CALLABLE_BIT_NV = 0x00002000, + VK_SHADER_STAGE_TASK_BIT_NV = 0x00000040, + VK_SHADER_STAGE_MESH_BIT_NV = 0x00000080, + 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 enum VkSamplerCreateFlagBits { + VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001, + VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002, + VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSamplerCreateFlagBits; +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_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000, + VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000, + VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000, + VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000, + 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_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000, + VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000, + VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000, + VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000, + 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 VkMemoryRequirements2 VkMemoryRequirements2KHR; + +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; + const 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" + + +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_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, + 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_MUTABLE_FORMAT_BIT_KHR = 0x00000004, + 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_shader_float16_int8 1 +#define VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION 1 +#define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8" + +typedef struct VkPhysicalDeviceFloat16Int8FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderFloat16; + VkBool32 shaderInt8; +} VkPhysicalDeviceFloat16Int8FeaturesKHR; + + + +#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_create_renderpass2 1 +#define VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION 1 +#define VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME "VK_KHR_create_renderpass2" + +typedef struct VkAttachmentDescription2KHR { + VkStructureType sType; + const void* pNext; + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription2KHR; + +typedef struct VkAttachmentReference2KHR { + VkStructureType sType; + const void* pNext; + uint32_t attachment; + VkImageLayout layout; + VkImageAspectFlags aspectMask; +} VkAttachmentReference2KHR; + +typedef struct VkSubpassDescription2KHR { + VkStructureType sType; + const void* pNext; + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t viewMask; + uint32_t inputAttachmentCount; + const VkAttachmentReference2KHR* pInputAttachments; + uint32_t colorAttachmentCount; + const VkAttachmentReference2KHR* pColorAttachments; + const VkAttachmentReference2KHR* pResolveAttachments; + const VkAttachmentReference2KHR* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; +} VkSubpassDescription2KHR; + +typedef struct VkSubpassDependency2KHR { + VkStructureType sType; + const void* pNext; + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; + int32_t viewOffset; +} VkSubpassDependency2KHR; + +typedef struct VkRenderPassCreateInfo2KHR { + VkStructureType sType; + const void* pNext; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + const VkAttachmentDescription2KHR* pAttachments; + uint32_t subpassCount; + const VkSubpassDescription2KHR* pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency2KHR* pDependencies; + uint32_t correlatedViewMaskCount; + const uint32_t* pCorrelatedViewMasks; +} VkRenderPassCreateInfo2KHR; + +typedef struct VkSubpassBeginInfoKHR { + VkStructureType sType; + const void* pNext; + VkSubpassContents contents; +} VkSubpassBeginInfoKHR; + +typedef struct VkSubpassEndInfoKHR { + VkStructureType sType; + const void* pNext; +} VkSubpassEndInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo); +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR( + VkDevice device, + const VkRenderPassCreateInfo2KHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfoKHR* pSubpassBeginInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR( + VkCommandBuffer commandBuffer, + const VkSubpassBeginInfoKHR* pSubpassBeginInfo, + const VkSubpassEndInfoKHR* pSubpassEndInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR( + VkCommandBuffer commandBuffer, + const VkSubpassEndInfoKHR* pSubpassEndInfo); +#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 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_KHR_8bit_storage 1 +#define VK_KHR_8BIT_STORAGE_SPEC_VERSION 1 +#define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage" + +typedef struct VkPhysicalDevice8BitStorageFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; +} VkPhysicalDevice8BitStorageFeaturesKHR; + + + +#define VK_KHR_shader_atomic_int64 1 +#define VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION 1 +#define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64" + +typedef struct VkPhysicalDeviceShaderAtomicInt64FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; +} VkPhysicalDeviceShaderAtomicInt64FeaturesKHR; + + + +#define VK_KHR_driver_properties 1 +#define VK_MAX_DRIVER_NAME_SIZE_KHR 256 +#define VK_MAX_DRIVER_INFO_SIZE_KHR 256 +#define VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION 1 +#define VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME "VK_KHR_driver_properties" + + +typedef enum VkDriverIdKHR { + VK_DRIVER_ID_AMD_PROPRIETARY_KHR = 1, + VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = 2, + VK_DRIVER_ID_MESA_RADV_KHR = 3, + VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR = 4, + VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = 5, + VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = 6, + VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = 7, + VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = 8, + VK_DRIVER_ID_ARM_PROPRIETARY_KHR = 9, + VK_DRIVER_ID_GOOGLE_PASTEL_KHR = 10, + VK_DRIVER_ID_BEGIN_RANGE_KHR = VK_DRIVER_ID_AMD_PROPRIETARY_KHR, + VK_DRIVER_ID_END_RANGE_KHR = VK_DRIVER_ID_GOOGLE_PASTEL_KHR, + VK_DRIVER_ID_RANGE_SIZE_KHR = (VK_DRIVER_ID_GOOGLE_PASTEL_KHR - VK_DRIVER_ID_AMD_PROPRIETARY_KHR + 1), + VK_DRIVER_ID_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDriverIdKHR; + +typedef struct VkConformanceVersionKHR { + uint8_t major; + uint8_t minor; + uint8_t subminor; + uint8_t patch; +} VkConformanceVersionKHR; + +typedef struct VkPhysicalDeviceDriverPropertiesKHR { + VkStructureType sType; + void* pNext; + VkDriverIdKHR driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE_KHR]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR]; + VkConformanceVersionKHR conformanceVersion; +} VkPhysicalDeviceDriverPropertiesKHR; + + + +#define VK_KHR_shader_float_controls 1 +#define VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION 1 +#define VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME "VK_KHR_shader_float_controls" + +typedef struct VkPhysicalDeviceFloatControlsPropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 separateDenormSettings; + VkBool32 separateRoundingModeSettings; + VkBool32 shaderSignedZeroInfNanPreserveFloat16; + VkBool32 shaderSignedZeroInfNanPreserveFloat32; + VkBool32 shaderSignedZeroInfNanPreserveFloat64; + VkBool32 shaderDenormPreserveFloat16; + VkBool32 shaderDenormPreserveFloat32; + VkBool32 shaderDenormPreserveFloat64; + VkBool32 shaderDenormFlushToZeroFloat16; + VkBool32 shaderDenormFlushToZeroFloat32; + VkBool32 shaderDenormFlushToZeroFloat64; + VkBool32 shaderRoundingModeRTEFloat16; + VkBool32 shaderRoundingModeRTEFloat32; + VkBool32 shaderRoundingModeRTEFloat64; + VkBool32 shaderRoundingModeRTZFloat16; + VkBool32 shaderRoundingModeRTZFloat32; + VkBool32 shaderRoundingModeRTZFloat64; +} VkPhysicalDeviceFloatControlsPropertiesKHR; + + + +#define VK_KHR_depth_stencil_resolve 1 +#define VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION 1 +#define VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME "VK_KHR_depth_stencil_resolve" + + +typedef enum VkResolveModeFlagBitsKHR { + VK_RESOLVE_MODE_NONE_KHR = 0, + VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = 0x00000001, + VK_RESOLVE_MODE_AVERAGE_BIT_KHR = 0x00000002, + VK_RESOLVE_MODE_MIN_BIT_KHR = 0x00000004, + VK_RESOLVE_MODE_MAX_BIT_KHR = 0x00000008, + VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkResolveModeFlagBitsKHR; +typedef VkFlags VkResolveModeFlagsKHR; + +typedef struct VkSubpassDescriptionDepthStencilResolveKHR { + VkStructureType sType; + const void* pNext; + VkResolveModeFlagBitsKHR depthResolveMode; + VkResolveModeFlagBitsKHR stencilResolveMode; + const VkAttachmentReference2KHR* pDepthStencilResolveAttachment; +} VkSubpassDescriptionDepthStencilResolveKHR; + +typedef struct VkPhysicalDeviceDepthStencilResolvePropertiesKHR { + VkStructureType sType; + void* pNext; + VkResolveModeFlagsKHR supportedDepthResolveModes; + VkResolveModeFlagsKHR supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; +} VkPhysicalDeviceDepthStencilResolvePropertiesKHR; + + + +#define VK_KHR_swapchain_mutable_format 1 +#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION 1 +#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format" + + +#define VK_KHR_vulkan_memory_model 1 +#define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 3 +#define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model" + +typedef struct VkPhysicalDeviceVulkanMemoryModelFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; +} VkPhysicalDeviceVulkanMemoryModelFeaturesKHR; + + + +#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" + + +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_ACCELERATION_STRUCTURE_NV_EXT = 1000165000, + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, + 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_EXT_transform_feedback 1 +#define VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION 1 +#define VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME "VK_EXT_transform_feedback" + +typedef VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT; + +typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 transformFeedback; + VkBool32 geometryStreams; +} VkPhysicalDeviceTransformFeedbackFeaturesEXT; + +typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxTransformFeedbackStreams; + uint32_t maxTransformFeedbackBuffers; + VkDeviceSize maxTransformFeedbackBufferSize; + uint32_t maxTransformFeedbackStreamDataSize; + uint32_t maxTransformFeedbackBufferDataSize; + uint32_t maxTransformFeedbackBufferDataStride; + VkBool32 transformFeedbackQueries; + VkBool32 transformFeedbackStreamsLinesTriangles; + VkBool32 transformFeedbackRasterizationStreamSelect; + VkBool32 transformFeedbackDraw; +} VkPhysicalDeviceTransformFeedbackPropertiesEXT; + +typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationStateStreamCreateFlagsEXT flags; + uint32_t rasterizationStream; +} VkPipelineRasterizationStateStreamCreateInfoEXT; + + +typedef void (VKAPI_PTR *PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes); +typedef void (VKAPI_PTR *PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index); +typedef void (VKAPI_PTR *PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags, + uint32_t index); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + uint32_t index); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT( + VkCommandBuffer commandBuffer, + uint32_t instanceCount, + uint32_t firstInstance, + VkBuffer counterBuffer, + VkDeviceSize counterBufferOffset, + uint32_t counterOffset, + uint32_t vertexStride); +#endif + +#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_NV_corner_sampled_image 1 +#define VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION 2 +#define VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME "VK_NV_corner_sampled_image" + +typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 cornerSampledImage; +} VkPhysicalDeviceCornerSampledImageFeaturesNV; + + + +#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; + const 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_EXT_astc_decode_mode 1 +#define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1 +#define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode" + +typedef struct VkImageViewASTCDecodeModeEXT { + VkStructureType sType; + const void* pNext; + VkFormat decodeMode; +} VkImageViewASTCDecodeModeEXT; + +typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 decodeModeSharedExponent; +} VkPhysicalDeviceASTCDecodeFeaturesEXT; + + + +#define VK_EXT_conditional_rendering 1 +#define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 1 +#define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering" + + +typedef enum VkConditionalRenderingFlagBitsEXT { + VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001, + VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkConditionalRenderingFlagBitsEXT; +typedef VkFlags VkConditionalRenderingFlagsEXT; + +typedef struct VkConditionalRenderingBeginInfoEXT { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; + VkDeviceSize offset; + VkConditionalRenderingFlagsEXT flags; +} VkConditionalRenderingBeginInfoEXT; + +typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 conditionalRendering; + VkBool32 inheritedConditionalRendering; +} VkPhysicalDeviceConditionalRenderingFeaturesEXT; + +typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 conditionalRenderingEnable; +} VkCommandBufferInheritanceConditionalRenderingInfoEXT; + + +typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); +typedef void (VKAPI_PTR *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT( + VkCommandBuffer commandBuffer, + const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT( + VkCommandBuffer commandBuffer); +#endif + +#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" + + +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_depth_clip_enable 1 +#define VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION 1 +#define VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME "VK_EXT_depth_clip_enable" + +typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT; + +typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 depthClipEnable; +} VkPhysicalDeviceDepthClipEnableFeaturesEXT; + +typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags; + VkBool32 depthClipEnable; +} VkPipelineRasterizationDepthClipStateCreateInfoEXT; + + + +#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; + const VkDebugUtilsLabelEXT* pQueueLabels; + uint32_t cmdBufLabelCount; + const VkDebugUtilsLabelEXT* pCmdBufLabels; + uint32_t objectCount; + const VkDebugUtilsObjectNameInfoEXT* pObjects; +} VkDebugUtilsMessengerCallbackDataEXT; + +typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)( + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + 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_inline_uniform_block 1 +#define VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION 1 +#define VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME "VK_EXT_inline_uniform_block" + +typedef struct VkPhysicalDeviceInlineUniformBlockFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 inlineUniformBlock; + VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; +} VkPhysicalDeviceInlineUniformBlockFeaturesEXT; + +typedef struct VkPhysicalDeviceInlineUniformBlockPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxInlineUniformBlockSize; + uint32_t maxPerStageDescriptorInlineUniformBlocks; + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + uint32_t maxDescriptorSetInlineUniformBlocks; + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; +} VkPhysicalDeviceInlineUniformBlockPropertiesEXT; + +typedef struct VkWriteDescriptorSetInlineUniformBlockEXT { + VkStructureType sType; + const void* pNext; + uint32_t dataSize; + const void* pData; +} VkWriteDescriptorSetInlineUniformBlockEXT; + +typedef struct VkDescriptorPoolInlineUniformBlockCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t maxInlineUniformBlockBindings; +} VkDescriptorPoolInlineUniformBlockCreateInfoEXT; + + + +#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_image_drm_format_modifier 1 +#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 1 +#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier" + +typedef struct VkDrmFormatModifierPropertiesEXT { + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + VkFormatFeatureFlags drmFormatModifierTilingFeatures; +} VkDrmFormatModifierPropertiesEXT; + +typedef struct VkDrmFormatModifierPropertiesListEXT { + VkStructureType sType; + void* pNext; + uint32_t drmFormatModifierCount; + VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties; +} VkDrmFormatModifierPropertiesListEXT; + +typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT { + VkStructureType sType; + const void* pNext; + uint64_t drmFormatModifier; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; +} VkPhysicalDeviceImageDrmFormatModifierInfoEXT; + +typedef struct VkImageDrmFormatModifierListCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t drmFormatModifierCount; + const uint64_t* pDrmFormatModifiers; +} VkImageDrmFormatModifierListCreateInfoEXT; + +typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + const VkSubresourceLayout* pPlaneLayouts; +} VkImageDrmFormatModifierExplicitCreateInfoEXT; + +typedef struct VkImageDrmFormatModifierPropertiesEXT { + VkStructureType sType; + void* pNext; + uint64_t drmFormatModifier; +} VkImageDrmFormatModifierPropertiesEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT( + VkDevice device, + VkImage image, + VkImageDrmFormatModifierPropertiesEXT* pProperties); +#endif + +#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" + + +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_NV_shading_rate_image 1 +#define VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION 3 +#define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image" + + +typedef enum VkShadingRatePaletteEntryNV { + VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0, + VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1, + VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2, + VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3, + VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11, + VK_SHADING_RATE_PALETTE_ENTRY_BEGIN_RANGE_NV = VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV, + VK_SHADING_RATE_PALETTE_ENTRY_END_RANGE_NV = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV, + VK_SHADING_RATE_PALETTE_ENTRY_RANGE_SIZE_NV = (VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV - VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV + 1), + VK_SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV = 0x7FFFFFFF +} VkShadingRatePaletteEntryNV; + +typedef enum VkCoarseSampleOrderTypeNV { + VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0, + VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1, + VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2, + VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3, + VK_COARSE_SAMPLE_ORDER_TYPE_BEGIN_RANGE_NV = VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV, + VK_COARSE_SAMPLE_ORDER_TYPE_END_RANGE_NV = VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV, + VK_COARSE_SAMPLE_ORDER_TYPE_RANGE_SIZE_NV = (VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV - VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV + 1), + VK_COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkCoarseSampleOrderTypeNV; + +typedef struct VkShadingRatePaletteNV { + uint32_t shadingRatePaletteEntryCount; + const VkShadingRatePaletteEntryNV* pShadingRatePaletteEntries; +} VkShadingRatePaletteNV; + +typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 shadingRateImageEnable; + uint32_t viewportCount; + const VkShadingRatePaletteNV* pShadingRatePalettes; +} VkPipelineViewportShadingRateImageStateCreateInfoNV; + +typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 shadingRateImage; + VkBool32 shadingRateCoarseSampleOrder; +} VkPhysicalDeviceShadingRateImageFeaturesNV; + +typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV { + VkStructureType sType; + void* pNext; + VkExtent2D shadingRateTexelSize; + uint32_t shadingRatePaletteSize; + uint32_t shadingRateMaxCoarseSamples; +} VkPhysicalDeviceShadingRateImagePropertiesNV; + +typedef struct VkCoarseSampleLocationNV { + uint32_t pixelX; + uint32_t pixelY; + uint32_t sample; +} VkCoarseSampleLocationNV; + +typedef struct VkCoarseSampleOrderCustomNV { + VkShadingRatePaletteEntryNV shadingRate; + uint32_t sampleCount; + uint32_t sampleLocationCount; + const VkCoarseSampleLocationNV* pSampleLocations; +} VkCoarseSampleOrderCustomNV; + +typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkCoarseSampleOrderTypeNV sampleOrderType; + uint32_t customSampleOrderCount; + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders; +} VkPipelineViewportCoarseSampleOrderStateCreateInfoNV; + + +typedef void (VKAPI_PTR *PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV( + VkCommandBuffer commandBuffer, + VkImageView imageView, + VkImageLayout imageLayout); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkShadingRatePaletteNV* pShadingRatePalettes); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV( + VkCommandBuffer commandBuffer, + VkCoarseSampleOrderTypeNV sampleOrderType, + uint32_t customSampleOrderCount, + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); +#endif + +#define VK_NV_ray_tracing 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV) + +#define VK_NV_RAY_TRACING_SPEC_VERSION 3 +#define VK_NV_RAY_TRACING_EXTENSION_NAME "VK_NV_ray_tracing" +#define VK_SHADER_UNUSED_NV (~0U) + + +typedef enum VkRayTracingShaderGroupTypeNV { + VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = 0, + VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = 1, + VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = 2, + VK_RAY_TRACING_SHADER_GROUP_TYPE_BEGIN_RANGE_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV, + VK_RAY_TRACING_SHADER_GROUP_TYPE_END_RANGE_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV, + VK_RAY_TRACING_SHADER_GROUP_TYPE_RANGE_SIZE_NV = (VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV - VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV + 1), + VK_RAY_TRACING_SHADER_GROUP_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkRayTracingShaderGroupTypeNV; + +typedef enum VkGeometryTypeNV { + VK_GEOMETRY_TYPE_TRIANGLES_NV = 0, + VK_GEOMETRY_TYPE_AABBS_NV = 1, + VK_GEOMETRY_TYPE_BEGIN_RANGE_NV = VK_GEOMETRY_TYPE_TRIANGLES_NV, + VK_GEOMETRY_TYPE_END_RANGE_NV = VK_GEOMETRY_TYPE_AABBS_NV, + VK_GEOMETRY_TYPE_RANGE_SIZE_NV = (VK_GEOMETRY_TYPE_AABBS_NV - VK_GEOMETRY_TYPE_TRIANGLES_NV + 1), + VK_GEOMETRY_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkGeometryTypeNV; + +typedef enum VkAccelerationStructureTypeNV { + VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = 0, + VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = 1, + VK_ACCELERATION_STRUCTURE_TYPE_BEGIN_RANGE_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV, + VK_ACCELERATION_STRUCTURE_TYPE_END_RANGE_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV, + VK_ACCELERATION_STRUCTURE_TYPE_RANGE_SIZE_NV = (VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV + 1), + VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkAccelerationStructureTypeNV; + +typedef enum VkCopyAccelerationStructureModeNV { + VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = 0, + VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = 1, + VK_COPY_ACCELERATION_STRUCTURE_MODE_BEGIN_RANGE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV, + VK_COPY_ACCELERATION_STRUCTURE_MODE_END_RANGE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV, + VK_COPY_ACCELERATION_STRUCTURE_MODE_RANGE_SIZE_NV = (VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV - VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV + 1), + VK_COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkCopyAccelerationStructureModeNV; + +typedef enum VkAccelerationStructureMemoryRequirementsTypeNV { + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BEGIN_RANGE_NV = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_END_RANGE_NV = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_RANGE_SIZE_NV = (VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV + 1), + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkAccelerationStructureMemoryRequirementsTypeNV; + + +typedef enum VkGeometryFlagBitsNV { + VK_GEOMETRY_OPAQUE_BIT_NV = 0x00000001, + VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = 0x00000002, + VK_GEOMETRY_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkGeometryFlagBitsNV; +typedef VkFlags VkGeometryFlagsNV; + +typedef enum VkGeometryInstanceFlagBitsNV { + VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = 0x00000001, + VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = 0x00000002, + VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = 0x00000004, + VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = 0x00000008, + VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkGeometryInstanceFlagBitsNV; +typedef VkFlags VkGeometryInstanceFlagsNV; + +typedef enum VkBuildAccelerationStructureFlagBitsNV { + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = 0x00000001, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = 0x00000002, + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = 0x00000004, + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = 0x00000008, + VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = 0x00000010, + VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkBuildAccelerationStructureFlagBitsNV; +typedef VkFlags VkBuildAccelerationStructureFlagsNV; + +typedef struct VkRayTracingShaderGroupCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkRayTracingShaderGroupTypeNV type; + uint32_t generalShader; + uint32_t closestHitShader; + uint32_t anyHitShader; + uint32_t intersectionShader; +} VkRayTracingShaderGroupCreateInfoNV; + +typedef struct VkRayTracingPipelineCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + uint32_t groupCount; + const VkRayTracingShaderGroupCreateInfoNV* pGroups; + uint32_t maxRecursionDepth; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkRayTracingPipelineCreateInfoNV; + +typedef struct VkGeometryTrianglesNV { + VkStructureType sType; + const void* pNext; + VkBuffer vertexData; + VkDeviceSize vertexOffset; + uint32_t vertexCount; + VkDeviceSize vertexStride; + VkFormat vertexFormat; + VkBuffer indexData; + VkDeviceSize indexOffset; + uint32_t indexCount; + VkIndexType indexType; + VkBuffer transformData; + VkDeviceSize transformOffset; +} VkGeometryTrianglesNV; + +typedef struct VkGeometryAABBNV { + VkStructureType sType; + const void* pNext; + VkBuffer aabbData; + uint32_t numAABBs; + uint32_t stride; + VkDeviceSize offset; +} VkGeometryAABBNV; + +typedef struct VkGeometryDataNV { + VkGeometryTrianglesNV triangles; + VkGeometryAABBNV aabbs; +} VkGeometryDataNV; + +typedef struct VkGeometryNV { + VkStructureType sType; + const void* pNext; + VkGeometryTypeNV geometryType; + VkGeometryDataNV geometry; + VkGeometryFlagsNV flags; +} VkGeometryNV; + +typedef struct VkAccelerationStructureInfoNV { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureTypeNV type; + VkBuildAccelerationStructureFlagsNV flags; + uint32_t instanceCount; + uint32_t geometryCount; + const VkGeometryNV* pGeometries; +} VkAccelerationStructureInfoNV; + +typedef struct VkAccelerationStructureCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkDeviceSize compactedSize; + VkAccelerationStructureInfoNV info; +} VkAccelerationStructureCreateInfoNV; + +typedef struct VkBindAccelerationStructureMemoryInfoNV { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureNV accelerationStructure; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; +} VkBindAccelerationStructureMemoryInfoNV; + +typedef struct VkWriteDescriptorSetAccelerationStructureNV { + VkStructureType sType; + const void* pNext; + uint32_t accelerationStructureCount; + const VkAccelerationStructureNV* pAccelerationStructures; +} VkWriteDescriptorSetAccelerationStructureNV; + +typedef struct VkAccelerationStructureMemoryRequirementsInfoNV { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureMemoryRequirementsTypeNV type; + VkAccelerationStructureNV accelerationStructure; +} VkAccelerationStructureMemoryRequirementsInfoNV; + +typedef struct VkPhysicalDeviceRayTracingPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t shaderGroupHandleSize; + uint32_t maxRecursionDepth; + uint32_t maxShaderGroupStride; + uint32_t shaderGroupBaseAlignment; + uint64_t maxGeometryCount; + uint64_t maxInstanceCount; + uint64_t maxTriangleCount; + uint32_t maxDescriptorSetAccelerationStructures; +} VkPhysicalDeviceRayTracingPropertiesNV; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure); +typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); +typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); +typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset); +typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode); +typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysNV)(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV( + VkDevice device, + const VkAccelerationStructureCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureNV* pAccelerationStructure); + +VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV( + VkDevice device, + VkAccelerationStructureNV accelerationStructure, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV( + VkDevice device, + const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV( + VkDevice device, + uint32_t bindInfoCount, + const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); + +VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV( + VkCommandBuffer commandBuffer, + const VkAccelerationStructureInfoNV* pInfo, + VkBuffer instanceData, + VkDeviceSize instanceOffset, + VkBool32 update, + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkBuffer scratch, + VkDeviceSize scratchOffset); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV( + VkCommandBuffer commandBuffer, + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkCopyAccelerationStructureModeNV mode); + +VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNV( + VkCommandBuffer commandBuffer, + VkBuffer raygenShaderBindingTableBuffer, + VkDeviceSize raygenShaderBindingOffset, + VkBuffer missShaderBindingTableBuffer, + VkDeviceSize missShaderBindingOffset, + VkDeviceSize missShaderBindingStride, + VkBuffer hitShaderBindingTableBuffer, + VkDeviceSize hitShaderBindingOffset, + VkDeviceSize hitShaderBindingStride, + VkBuffer callableShaderBindingTableBuffer, + VkDeviceSize callableShaderBindingOffset, + VkDeviceSize callableShaderBindingStride, + uint32_t width, + uint32_t height, + uint32_t depth); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoNV* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV( + VkDevice device, + VkAccelerationStructureNV accelerationStructure, + size_t dataSize, + void* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV( + VkCommandBuffer commandBuffer, + uint32_t accelerationStructureCount, + const VkAccelerationStructureNV* pAccelerationStructures, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery); + +VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV( + VkDevice device, + VkPipeline pipeline, + uint32_t shader); +#endif + +#define VK_NV_representative_fragment_test 1 +#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 1 +#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test" + +typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 representativeFragmentTest; +} VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV; + +typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 representativeFragmentTestEnable; +} VkPipelineRepresentativeFragmentTestStateCreateInfoNV; + + + +#define VK_EXT_filter_cubic 1 +#define VK_EXT_FILTER_CUBIC_SPEC_VERSION 1 +#define VK_EXT_FILTER_CUBIC_EXTENSION_NAME "VK_EXT_filter_cubic" + +typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT { + VkStructureType sType; + void* pNext; + VkImageViewType imageViewType; +} VkPhysicalDeviceImageViewImageFormatInfoEXT; + +typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 filterCubic; + VkBool32 filterCubicMinmax ; +} VkFilterCubicImageViewImageFormatPropertiesEXT; + + + +#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_EXT_calibrated_timestamps 1 +#define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 1 +#define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps" + + +typedef enum VkTimeDomainEXT { + VK_TIME_DOMAIN_DEVICE_EXT = 0, + VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1, + VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2, + VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3, + VK_TIME_DOMAIN_BEGIN_RANGE_EXT = VK_TIME_DOMAIN_DEVICE_EXT, + VK_TIME_DOMAIN_END_RANGE_EXT = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT, + VK_TIME_DOMAIN_RANGE_SIZE_EXT = (VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT - VK_TIME_DOMAIN_DEVICE_EXT + 1), + VK_TIME_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF +} VkTimeDomainEXT; + +typedef struct VkCalibratedTimestampInfoEXT { + VkStructureType sType; + const void* pNext; + VkTimeDomainEXT timeDomain; +} VkCalibratedTimestampInfoEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains); +typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( + VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainEXT* pTimeDomains); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT( + VkDevice device, + uint32_t timestampCount, + const VkCalibratedTimestampInfoEXT* pTimestampInfos, + uint64_t* pTimestamps, + uint64_t* pMaxDeviation); +#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_AMD_memory_overallocation_behavior 1 +#define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION 1 +#define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME "VK_AMD_memory_overallocation_behavior" + + +typedef enum VkMemoryOverallocationBehaviorAMD { + VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_BEGIN_RANGE_AMD = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_END_RANGE_AMD = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_RANGE_SIZE_AMD = (VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD - VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD + 1), + VK_MEMORY_OVERALLOCATION_BEHAVIOR_MAX_ENUM_AMD = 0x7FFFFFFF +} VkMemoryOverallocationBehaviorAMD; + +typedef struct VkDeviceMemoryOverallocationCreateInfoAMD { + VkStructureType sType; + const void* pNext; + VkMemoryOverallocationBehaviorAMD overallocationBehavior; +} VkDeviceMemoryOverallocationCreateInfoAMD; + + + +#define VK_EXT_vertex_attribute_divisor 1 +#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 3 +#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; + +typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 vertexAttributeInstanceRateDivisor; + VkBool32 vertexAttributeInstanceRateZeroDivisor; +} VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT; + + + +#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" + + +#define VK_NV_compute_shader_derivatives 1 +#define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1 +#define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives" + +typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 computeDerivativeGroupQuads; + VkBool32 computeDerivativeGroupLinear; +} VkPhysicalDeviceComputeShaderDerivativesFeaturesNV; + + + +#define VK_NV_mesh_shader 1 +#define VK_NV_MESH_SHADER_SPEC_VERSION 1 +#define VK_NV_MESH_SHADER_EXTENSION_NAME "VK_NV_mesh_shader" + +typedef struct VkPhysicalDeviceMeshShaderFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 taskShader; + VkBool32 meshShader; +} VkPhysicalDeviceMeshShaderFeaturesNV; + +typedef struct VkPhysicalDeviceMeshShaderPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t maxDrawMeshTasksCount; + uint32_t maxTaskWorkGroupInvocations; + uint32_t maxTaskWorkGroupSize[3]; + uint32_t maxTaskTotalMemorySize; + uint32_t maxTaskOutputCount; + uint32_t maxMeshWorkGroupInvocations; + uint32_t maxMeshWorkGroupSize[3]; + uint32_t maxMeshTotalMemorySize; + uint32_t maxMeshOutputVertices; + uint32_t maxMeshOutputPrimitives; + uint32_t maxMeshMultiviewViewCount; + uint32_t meshOutputPerVertexGranularity; + uint32_t meshOutputPerPrimitiveGranularity; +} VkPhysicalDeviceMeshShaderPropertiesNV; + +typedef struct VkDrawMeshTasksIndirectCommandNV { + uint32_t taskCount; + uint32_t firstTask; +} VkDrawMeshTasksIndirectCommandNV; + + +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountNV)(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 vkCmdDrawMeshTasksNV( + VkCommandBuffer commandBuffer, + uint32_t taskCount, + uint32_t firstTask); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); +#endif + +#define VK_NV_fragment_shader_barycentric 1 +#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1 +#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric" + +typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 fragmentShaderBarycentric; +} VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV; + + + +#define VK_NV_shader_image_footprint 1 +#define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 1 +#define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint" + +typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 imageFootprint; +} VkPhysicalDeviceShaderImageFootprintFeaturesNV; + + + +#define VK_NV_scissor_exclusive 1 +#define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 1 +#define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive" + +typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t exclusiveScissorCount; + const VkRect2D* pExclusiveScissors; +} VkPipelineViewportExclusiveScissorStateCreateInfoNV; + +typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 exclusiveScissor; +} VkPhysicalDeviceExclusiveScissorFeaturesNV; + + +typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV( + VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkRect2D* pExclusiveScissors); +#endif + +#define VK_NV_device_diagnostic_checkpoints 1 +#define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION 2 +#define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME "VK_NV_device_diagnostic_checkpoints" + +typedef struct VkQueueFamilyCheckpointPropertiesNV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlags checkpointExecutionStageMask; +} VkQueueFamilyCheckpointPropertiesNV; + +typedef struct VkCheckpointDataNV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlagBits stage; + void* pCheckpointMarker; +} VkCheckpointDataNV; + + +typedef void (VKAPI_PTR *PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void* pCheckpointMarker); +typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV( + VkCommandBuffer commandBuffer, + const void* pCheckpointMarker); + +VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV( + VkQueue queue, + uint32_t* pCheckpointDataCount, + VkCheckpointDataNV* pCheckpointData); +#endif + +#define VK_EXT_pci_bus_info 1 +#define VK_EXT_PCI_BUS_INFO_SPEC_VERSION 2 +#define VK_EXT_PCI_BUS_INFO_EXTENSION_NAME "VK_EXT_pci_bus_info" + +typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t pciDomain; + uint32_t pciBus; + uint32_t pciDevice; + uint32_t pciFunction; +} VkPhysicalDevicePCIBusInfoPropertiesEXT; + + + +#define VK_EXT_fragment_density_map 1 +#define VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION 1 +#define VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME "VK_EXT_fragment_density_map" + +typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 fragmentDensityMap; + VkBool32 fragmentDensityMapDynamic; + VkBool32 fragmentDensityMapNonSubsampledImages; +} VkPhysicalDeviceFragmentDensityMapFeaturesEXT; + +typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT { + VkStructureType sType; + void* pNext; + VkExtent2D minFragmentDensityTexelSize; + VkExtent2D maxFragmentDensityTexelSize; + VkBool32 fragmentDensityInvocations; +} VkPhysicalDeviceFragmentDensityMapPropertiesEXT; + +typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkAttachmentReference fragmentDensityMapAttachment; +} VkRenderPassFragmentDensityMapCreateInfoEXT; + + + +#define VK_EXT_scalar_block_layout 1 +#define VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION 1 +#define VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME "VK_EXT_scalar_block_layout" + +typedef struct VkPhysicalDeviceScalarBlockLayoutFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 scalarBlockLayout; +} VkPhysicalDeviceScalarBlockLayoutFeaturesEXT; + + + +#define VK_GOOGLE_hlsl_functionality1 1 +#define VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION 1 +#define VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME "VK_GOOGLE_hlsl_functionality1" + + +#define VK_GOOGLE_decorate_string 1 +#define VK_GOOGLE_DECORATE_STRING_SPEC_VERSION 1 +#define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string" + + +#define VK_EXT_memory_budget 1 +#define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1 +#define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget" + +typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS]; + VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryBudgetPropertiesEXT; + + + +#define VK_EXT_memory_priority 1 +#define VK_EXT_MEMORY_PRIORITY_SPEC_VERSION 1 +#define VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME "VK_EXT_memory_priority" + +typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 memoryPriority; +} VkPhysicalDeviceMemoryPriorityFeaturesEXT; + +typedef struct VkMemoryPriorityAllocateInfoEXT { + VkStructureType sType; + const void* pNext; + float priority; +} VkMemoryPriorityAllocateInfoEXT; + + + +#define VK_NV_dedicated_allocation_image_aliasing 1 +#define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION 1 +#define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME "VK_NV_dedicated_allocation_image_aliasing" + +typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 dedicatedAllocationImageAliasing; +} VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + + + +#define VK_EXT_buffer_device_address 1 +typedef uint64_t VkDeviceAddress; + +#define VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 2 +#define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address" + +typedef struct VkPhysicalDeviceBufferAddressFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; +} VkPhysicalDeviceBufferAddressFeaturesEXT; + +typedef struct VkBufferDeviceAddressInfoEXT { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferDeviceAddressInfoEXT; + +typedef struct VkBufferDeviceAddressCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceSize deviceAddress; +} VkBufferDeviceAddressCreateInfoEXT; + + +typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT( + VkDevice device, + const VkBufferDeviceAddressInfoEXT* pInfo); +#endif + +#define VK_EXT_separate_stencil_usage 1 +#define VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION 1 +#define VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME "VK_EXT_separate_stencil_usage" + +typedef struct VkImageStencilUsageCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags stencilUsage; +} VkImageStencilUsageCreateInfoEXT; + + + +#define VK_EXT_validation_features 1 +#define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 1 +#define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features" + + +typedef enum VkValidationFeatureEnableEXT { + VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0, + VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1, + VK_VALIDATION_FEATURE_ENABLE_BEGIN_RANGE_EXT = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT, + VK_VALIDATION_FEATURE_ENABLE_END_RANGE_EXT = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT, + VK_VALIDATION_FEATURE_ENABLE_RANGE_SIZE_EXT = (VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT - VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT + 1), + VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationFeatureEnableEXT; + +typedef enum VkValidationFeatureDisableEXT { + VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0, + VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1, + VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2, + VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3, + VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4, + VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5, + VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6, + VK_VALIDATION_FEATURE_DISABLE_BEGIN_RANGE_EXT = VK_VALIDATION_FEATURE_DISABLE_ALL_EXT, + VK_VALIDATION_FEATURE_DISABLE_END_RANGE_EXT = VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT, + VK_VALIDATION_FEATURE_DISABLE_RANGE_SIZE_EXT = (VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT - VK_VALIDATION_FEATURE_DISABLE_ALL_EXT + 1), + VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationFeatureDisableEXT; + +typedef struct VkValidationFeaturesEXT { + VkStructureType sType; + const void* pNext; + uint32_t enabledValidationFeatureCount; + const VkValidationFeatureEnableEXT* pEnabledValidationFeatures; + uint32_t disabledValidationFeatureCount; + const VkValidationFeatureDisableEXT* pDisabledValidationFeatures; +} VkValidationFeaturesEXT; + + + +#define VK_NV_cooperative_matrix 1 +#define VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION 1 +#define VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_NV_cooperative_matrix" + + +typedef enum VkComponentTypeNV { + VK_COMPONENT_TYPE_FLOAT16_NV = 0, + VK_COMPONENT_TYPE_FLOAT32_NV = 1, + VK_COMPONENT_TYPE_FLOAT64_NV = 2, + VK_COMPONENT_TYPE_SINT8_NV = 3, + VK_COMPONENT_TYPE_SINT16_NV = 4, + VK_COMPONENT_TYPE_SINT32_NV = 5, + VK_COMPONENT_TYPE_SINT64_NV = 6, + VK_COMPONENT_TYPE_UINT8_NV = 7, + VK_COMPONENT_TYPE_UINT16_NV = 8, + VK_COMPONENT_TYPE_UINT32_NV = 9, + VK_COMPONENT_TYPE_UINT64_NV = 10, + VK_COMPONENT_TYPE_BEGIN_RANGE_NV = VK_COMPONENT_TYPE_FLOAT16_NV, + VK_COMPONENT_TYPE_END_RANGE_NV = VK_COMPONENT_TYPE_UINT64_NV, + VK_COMPONENT_TYPE_RANGE_SIZE_NV = (VK_COMPONENT_TYPE_UINT64_NV - VK_COMPONENT_TYPE_FLOAT16_NV + 1), + VK_COMPONENT_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkComponentTypeNV; + +typedef enum VkScopeNV { + VK_SCOPE_DEVICE_NV = 1, + VK_SCOPE_WORKGROUP_NV = 2, + VK_SCOPE_SUBGROUP_NV = 3, + VK_SCOPE_QUEUE_FAMILY_NV = 5, + VK_SCOPE_BEGIN_RANGE_NV = VK_SCOPE_DEVICE_NV, + VK_SCOPE_END_RANGE_NV = VK_SCOPE_QUEUE_FAMILY_NV, + VK_SCOPE_RANGE_SIZE_NV = (VK_SCOPE_QUEUE_FAMILY_NV - VK_SCOPE_DEVICE_NV + 1), + VK_SCOPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkScopeNV; + +typedef struct VkCooperativeMatrixPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t MSize; + uint32_t NSize; + uint32_t KSize; + VkComponentTypeNV AType; + VkComponentTypeNV BType; + VkComponentTypeNV CType; + VkComponentTypeNV DType; + VkScopeNV scope; +} VkCooperativeMatrixPropertiesNV; + +typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 cooperativeMatrix; + VkBool32 cooperativeMatrixRobustBufferAccess; +} VkPhysicalDeviceCooperativeMatrixFeaturesNV; + +typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV { + VkStructureType sType; + void* pNext; + VkShaderStageFlags cooperativeMatrixSupportedStages; +} VkPhysicalDeviceCooperativeMatrixPropertiesNV; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkCooperativeMatrixPropertiesNV* pProperties); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/moltenvk/include/vulkan/vulkan_fuchsia.h b/moltenvk/include/vulkan/vulkan_fuchsia.h new file mode 100644 index 00000000..1c335fd3 --- /dev/null +++ b/moltenvk/include/vulkan/vulkan_fuchsia.h @@ -0,0 +1,58 @@ +#ifndef VULKAN_FUCHSIA_H_ +#define VULKAN_FUCHSIA_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2019 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_FUCHSIA_imagepipe_surface 1 +#define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1 +#define VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME "VK_FUCHSIA_imagepipe_surface" + +typedef VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA; + +typedef struct VkImagePipeSurfaceCreateInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkImagePipeSurfaceCreateFlagsFUCHSIA flags; + zx_handle_t imagePipeHandle; +} VkImagePipeSurfaceCreateInfoFUCHSIA; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateImagePipeSurfaceFUCHSIA)(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA( + VkInstance instance, + const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/moltenvk/include/vulkan/vulkan_ios.h b/moltenvk/include/vulkan/vulkan_ios.h new file mode 100644 index 00000000..d221a9ba --- /dev/null +++ b/moltenvk/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-2019 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/moltenvk/include/vulkan/vulkan_macos.h b/moltenvk/include/vulkan/vulkan_macos.h new file mode 100644 index 00000000..5d6b6aeb --- /dev/null +++ b/moltenvk/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-2019 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/moltenvk/include/vulkan/vulkan_mir.h b/moltenvk/include/vulkan/vulkan_mir.h new file mode 100644 index 00000000..7d24ed27 --- /dev/null +++ b/moltenvk/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/moltenvk/include/vulkan/vulkan_vi.h b/moltenvk/include/vulkan/vulkan_vi.h new file mode 100644 index 00000000..3e37bab6 --- /dev/null +++ b/moltenvk/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-2019 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/moltenvk/include/vulkan/vulkan_wayland.h b/moltenvk/include/vulkan/vulkan_wayland.h new file mode 100644 index 00000000..33a22de3 --- /dev/null +++ b/moltenvk/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-2019 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/moltenvk/include/vulkan/vulkan_win32.h b/moltenvk/include/vulkan/vulkan_win32.h new file mode 100644 index 00000000..b9d63d47 --- /dev/null +++ b/moltenvk/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-2019 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/moltenvk/include/vulkan/vulkan_xcb.h b/moltenvk/include/vulkan/vulkan_xcb.h new file mode 100644 index 00000000..f2129097 --- /dev/null +++ b/moltenvk/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-2019 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/moltenvk/include/vulkan/vulkan_xlib.h b/moltenvk/include/vulkan/vulkan_xlib.h new file mode 100644 index 00000000..ce3d36dd --- /dev/null +++ b/moltenvk/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-2019 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/moltenvk/include/vulkan/vulkan_xlib_xrandr.h b/moltenvk/include/vulkan/vulkan_xlib_xrandr.h new file mode 100644 index 00000000..25efb077 --- /dev/null +++ b/moltenvk/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-2019 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/moltenvk/lib/libMoltenVK.dylib b/moltenvk/lib/libMoltenVK.dylib new file mode 100755 index 0000000000000000000000000000000000000000..db49770f5ed8491d261474d55a11ffe1039dd1d4 GIT binary patch literal 2978632 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

`UjeE=R7|rcP)Fd9sFL5# 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

1{Z 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

0OMb2_A4O_FFW2E3@ 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%0Dq;G15xq>mb?TBquw^Rm;B1d-zVdvv zDLN8nP8e}D(>UVLy-L#r&*9C?PPrcp)@pD64Tm`@ncDTcMu$Fgn?H^o-NMPtj09GGb? zI1M7k;lm~J3&}G6Z53fRuZl3=kx;epKhPG54k=kwREWl<S>Vv{h&KU=MExMCOCP z#JR7Lwi@m6s1i!2HvDj*^iS+^5(5rBCiQ{m9-jz!<}Zf_Dsd)A897re=#q%>K2)k0 zMl}2wj3GD~D#G?u4f-*9goNnw)T1BNDnIAwHJ^ls|R+9Kvlew z`@5-1=trn3~DszoQ>16l77t^??!M+dKnqib!A-uRj~)V*@WEp3p>?7ihtIGxj;R(;bb#90i8A+HQgjUJ?eT;2 z?FWCQ$nmYuzJnZNN;6&KtNakUs_?-UWf#%^j<#z3f_*Vy6s{>&_H*0zz+MgpiaSt2 zZQmzjaAZ9E;e@IO@G*vm|golprm!N;b*}09_FjuP8uL%k-fITqTT2URffvLcr$(g z!yeqZmGtL1+7|tMe1RmYQ4Ce4rwQ zcE>5vdix`KHDuA6zKza$0_Q14UDo09j(s)pl0l~+(2B-o^d8^>q9Xo*;D5;uR2KG^ zPMbyGSGg(P5}8YVAaE~4w8=~T=Bvokmy3z*5;2{yMg!Z8T7(9%yssVsaO+^?+c8i! zI{3y@4mL!Q^ZCx{1fnp=pF^uTiaYg@ch{W$l2)p{#e*SHLWg zqk8Z@fi76-w!_J zCvnZ+>C;>AK%B!!MYQm`4X<2^Pe(Fd#$JJ3WxO}HKOYyLjHsw$i3(TeeMK>SJ&}mE z8^5PBa#xE&Ya}+baOT$>kt-{-qwUjS3V6OGK!ad+!5WSPpc**`Onu(=~S>jcvW8ynCwq(HHXKLR}j3WZI)+aJsi2#&7#_VcyvfDaR;_}vefA1WS{p7=kU zAIi`k)S*59@&ESx@c2(rx9>4O(4Q101}ujgLqn4j!%bj($%)~7&>8H${bno0-#g%& z7U03?U}skF!|=BJd^IbS$ElEIeBR_kPQe-^aHV1W*qIgIlB(K)#|Sq90!A#_quG5-K9dQf>V z|6q?A_zM|oUIO{#BAGJi2LX|_O0KcMKP()4OJU7jy6GW%#`|PE@*JJHv;Q@@2F~uB!Y{1WKEWv>zX>lK@ZQ_DhWk!bq~If~ zMmPI7m_=@Upd^BRyftYX=bv=dRgdZ)H@rTWj$a22zw%@rQPb>QuH+wnZ9pi-)zCTWJ!Y`1@ z;e;FTN=`Tl$&Rr<{zK)(SuEXL`+vv}Zb1de5B~hY|298(D2lrMclbf~2h#aLCcb|t zKX?^Q{r~vE|KkU+^}|wZt>OpU@00Ndeqe|R({B5fCBhFD-RR{9Q*RJ{u=RSy58g*A zhaWtLSMr0ANOlZ!>Z}Lf%@}00{iD^Ne)OKt$0r;-)!S7#MUVAT+d$mZG6)Ph#w7p`3m5%m3?lv!&Q99e|+ozq^Qv>C3YUM0|K zyAca9oLqc(O|)d|0Sd6m^=4XsLJ)QIvApQ*B^VV#{&B2MtX6Qzu5)zv1;>x>2ZE#*ISokmF3$8qzE5L$gL$LQjxH*UF z0gD&hg&Bwj*V_T820;@rZ1AlwX)^)B)IFKO!q1IA@`zfAnU6!ii4zoR>a?#{L*leI zWa+$d@mu_qPefjp?~8`I-$&8IW$EsfwON2f^sMd-bxar{-%-_y#TqK zlEO*dX7^6yI`o8jQXn8EERuFpAMk17wp4qUkH>|TSR+6UjG!%v;iAqcG2espR)6bO zadw`vk=eXh#;+fqML_dP(sM_dc>*UE7ncb9;ouYv#)i4uA0C)t_|(qSeaNB2oN(-Y zsa9es;_geehm;4`DY7s1OZX0h8Y(xbHu35cRC{JWd7aC7;Il2e3y{`%2G5+I59fW& z*E^~GsRf_*f;4Etwi}DW=&C-z8;&KHA+um~Mp3|gGKN)hAo|35JRtAfjBB@Xl)Okc zql}70V4nC~ovh7|R5K<#j0P9MiT}9QK~^h)1umS6AtrVm@5u|8s~8D~H>U*5E$m8mN4E3` z45p+qGg zn5UJ$rG5!mkN<0e36uImMlm;1K|fKdWcJYWMK9on*fr7I&bj%VwZc>3wg;pF}+O z@)%61RE!t!`r$Kz)`i85LzLg4`S~!|SJO``Jh9ot{q1*k%zA3WN3Hl0l^E6*Rc_$! zXDkg^{Tm16Deq^!?9B*dOV;8UfG-yqAL3{+bdPC@#AOnCz^+_)?Dn?b%!l3_6S%_< z$HixZ5L5b&;_F5hW0w-@DQNwm(9tSiMk|(pNTPn2DBznmNF?FHosQ+1*tfn(>oIrZ zhn9#se3fzU_+GptUFa&c9;APfE+vJ7bB#0NG%5A+k2HG)cyOV;?4`&A=Q{=|ds%ow zDilRE>}5CL(7u5in0FW_Fu%~nPUM|jOTDJ|*zLh6G6RDLVnhkH*6+pC1qni(m(o9+hB{#)4;6v=+;DW*tWVGJCD!f-CBx7|E z{@G`O?Dgj^y7-cQmtIy-2wl--`g3E(UVp>QefnO6uRi*7!$(|m?Z{E1ufta_{kb8! zf9SA4@M?VJ>(AYBXYo~oN_;Thhw|;Y+sn#B#_TzB@s+DTH}%IqnKpgK%vt!#(Vv@m z%cNUNC*L-OiYd5a)Ouy_eH+Uo;8R;PP_V~F+#{hYU_z0bxEvR&%GO!~clRTgp>13; ztQ#a_&h>*hxvpi4n`;NP$dI|m-}G`II-a0Pc-MQ+B^H$yGo zgu6p_YA@~Mrs@3vB9*^sv$2(D$HD#{!8T{^60{SX%IPKyE39A)2II|I5}HjYXXjPh zJJ2&8&u1I(sdhi~bZ#bbIwX35oi+NZu**S!0VTn1`wob%*fM2qOWfRGMv5VPm*lqF z9wRZD?Uye2l#_;75og~r0z4L`voO9jjmo6Ur&kf7*xaAAA^#)3gHY?Lp%DP%r42bO zWm+YTcWAWd8c5vF{9!^q#FY=^d;`WuVL8t~6}6V(k>ZzWE%jt@1*IxGi@Y-hl~C zOQ@5Fcll+|Cs!k1t&-ke;p$GSd=kw|g?Cb(b@rP>ov|aR4AoI6Etj>(W+XbE1;rX; zI8@+9@8jA_w8t?s*S3h2;#y}89RV`yNv1$!@-QDN=3EEk%UsL?| zTkxY@jkaPCw*pQGz(zUl~Z=9EGkFJ7=+a7ioj5PEXRBfs? z4xwHSQ7%XX*jt|ZxcI=nocI{$IV}JyX4L{G$GNecs`itq+~DkJ+)Cx}^09dome+~3 zRxNbrMip89S9h^nreUMboj)zmzBQ!idsv!&B`16ix+i>^)Cr$Ap_Ll0dk*;EYLCUR zEW_B3qrbGsU(lTK8vILb=re_Z13p;;Wj_^01KyV=XWC6gifWfVz z_EY=e3Ms;DFh+89>*2Y0)vf3(JQ8h5BUn{DOk)V#01cy=x9`9LXh|RJYhlI=*5L_v zdYFo=vANA{_3DabQj~cmXL6md3Pu@FF#D=&QG+_)GW2K$FDRK;W&f19E;gzVimZZg z{xiH4HvvqzMXvMJF(#fdJ{u#%Ubfa&>3Fk0yOS6(?YL^JU+ZmNVyH)hkHI!)Cm1YT zD8TzQ{X*=re+pL-RN#Qay4)4rtW{nL?&6QmN4qzL&@+ue`2IPa92Vwhj-hfNB zx{{%o#!{GmPhi#3`IB3}wt5fv%>%!D2GPHzRx*v84!aS@{ytToe#!cD1Ag9`tg}A^ zN$KzaK%8V6S;~5RiFr9$4_em8FC(rXg74M-?TM+gw~U)Qd@`YQkN*#HO{GsU)_YT> zu?XXdI7J^R&BL#cY7dSKw-jg*R4FIN3y@nX?{k{v{T%Ku=pm>6^p-8@O1KF;Icike z=Lb#%!@&4J_XcNEEUZ!v-m2}t&!JZZG7q&@=7QdS6hJ5n{xDd{Zglz*krSdgK@Y^d z@}sawW2u@iZbv$qFaGHdzwFExdu{A;gP>^G@xM4Uekb*lvp zWdi2uL(Pu+ocY2%|0#0?&wn0N=RY||B+q}QD4|hUJmkJOZ3V1VW5=-~K6Lh+}-NN-FV@%;#w~vWIrGeWz%&{1)oFD2zJ$~geejiMB_mc*Ge0Ze>;qMUIi zAr7B6x^ZQuFiv;yGX}_1q&s;S*HG>Hvof{HQFF;-p=1?9TN73UOoz-2fmnzf>}p^|9Oskk2!T=ArP{=gzqr5_GiPa~f*rdL2@0xunm= zT3>x%-_NB5xV;FHOBdvId;PloBpdZ)f}q;bn_Wit&djD1@$ zS-*F!x13X0&cE8YEBAV2l$Xj#aGW~B#c|}+J4 zV^S%K-XS#}G;Qjv5+YIyTs_r&klD=m{@EDQrX4GrVa(?2R5mUq$rit^v@Aqy*y3~j zC0-OXrcIpaZHcaKdVQs;ho6ORmzwxz0HkWN%bU&m24wR%vT@U*>~8wX=~F{fXO~L) zH&x%4O`SefrQhvMznJN7O+&-eppzzsKq!)pYEb`-*)u1pY|33yxAv0=|mQgyT6Nf>> z0kko5X4$RHD19%6VSH20aT4*|QrWmV(h&u{aWIAG|Gkj}(X=K`i*?iNgIhoD~4W2k@>WtfvUXkhGvYBf5 z*ZR`P^u5oJeihOmkGGASIDOVM)*r12y7zYJ6HL1xl{TGul?qp!IumJCmnL%}ZKN^D zo0w5ST1K9>K>4NQgUPl?X4I@LIx(AlI8U7-`J=l;*bVD4D>S7UWxVkz(m$P+{;brH zDU%^Okvvq@M=zZ=%i%%qHRJjgbGj`pC(qz3`^gaU@f3|+ZA>4-c4|&zCCn!OxY-~N za`GfXV`d`fV`TG90@>`O3q*%;C|0Jh@USvZ`ZO9@#q_^K`c%92aJL%w(hr?VQ>oI5FAGHYNg?BrzpwztdxllMwX?r9>@j??dGB4R+X zKsCQ_#_dL_QA)l6VoGbG194=!4a?|MMLeTJ;WT_Q69T2l<)xu!qvKho{~48hX;c)L zI-_)AnV%(s)2M6$$C?o5F#X8mmG2d9Q2sF_l*^d@b-$)@cTg(q_$2&Gh%BrS}X5G`*W1g8{iohp61%Q@N!LhFh51m1((o z2*q0s5{e&lSsJ07!Q@=$E3#iYHA(iZSG!~nvKCoG?XC!wgZ9<#N~!>;e~R*M^%7wn zZn%(Z6Vm%TR65s{9MsH`6vdj&EQ^?a5^zg3w1)>mm~^vIT*D)Wr3oNK%!a44QrUO} zkRhS(Eg>KH2pMtdbIgnaGR1r^QTuPqXvuLi`u-S|BBMmfG0_?F{n0rMxrpC)EKBF@ zu`6x^4TRU_t8GAT8qrz$J0P+69{iJSBtkY4ve^sa#V+v|y^uc;@@FsPAwnMULKYHo zuNN|lkdPNLo{(F-kN_bgypYQY;Ydhg*o%h~nL?R~8}kG?z^E1xO{{h<{1Q z9zs6!Lbxds-|B_XrBpoTh5VV2zj+~#5b_%@mPLH~`|@=yT#2cgHI{Uo#Szk%ah+Nr@l3uVWK8yRX5-DEIZMgx`I=3|@zv zWalL=c3*oq+n@EBM(0F#7uqIqlJiQ93`jq6E7{*}d*UtB7{Cr-1lB-b;zu8Omta|V z7k+E-JA$7N3+4!Zui%#r6?*``hwF|VHI?G`1b(05ciz96nx^3QG=9wMAf5%d zfM_9p8}Q48ecA~8{s+JP_+gi@X(4_!_;rS-+UxLRx}W2@9l!4IMLG_@zu@-?euJ@d z&)xe&Slavx&+hn5#_uWoXdfW@iRAgM1)naHPRGHwrV^{XqxS5e6QlYe?b!|CudbSN zJ2VR~c1O2NYP(o83jym4AI?5y!Qv-pvbHxyJE95LDub;LJ>Q|vM9)(#jprOCUPBih zI7Y06=VFDzqr{6P4R$6bGAYmU{Tda`$$$$`G1Qx0cTpjpDUw8rS8i9gf&VT}1yo=2vwV(W|Wb>QZ z{o|d~UX)h(_R;vh4iL6W=tm04>iMv;AH6^<+VWu0CVd)xVhRJou_E+7d!ye%H4ONdkM361Vbw3!>gE4mdfB`yXI!@z@A^kxKMAyu1-p+i^LFD znyfCeGWA-WdR^wc)wTYOVV7R+!sAZ;GU)Sg z(zQMS%MZF%i2MnF_<{DRuB$?~RTBraYgLQcwZ7j;Kh1*6)p-^6t8cQCDwx$k)k)Bn zk6s+_@9CtN+wmZR_WH`F~HT>o}Z#W>S%YdMP26rhff0fGNKEyu8T%e{1x%FXNTp4ziO%73q^Z|H7m;+(Uv;X&0L+_2arpc zRkgmV6Wkis`5v1-5d#JE?o{vd?aAtG$66LUOiH}NQCiDu%ON*)$6Lb+}Q{_YlAFPRW4wWw-aI9{Yi)#3z zncy{8RXR+tv{_w$%Y3FFAL;U(@R1^|a!WgfT=+=7R#}0M@R3|C(ppBuQL|54XHS_p zZSpbEEnqR3&CvCW-^Itb(lIs(N=j!#tLVeB%QM}T&S*ZNj3j#9Qs@cY9IsC% zPn=eMoIYv8d|pp6Aj#*b#sXff?#R&0^l5nFZO!}mg`LQ+68Sm2T|5HS!iC63a3ONQ z&I3WhEDG0sF7<~u;~>9L0mFdB*r4V_fSr9XO*#=dhOxPc-a-1&4pizX5NEv&1C6Pe zYG{ia87k07dQhf`7jBZqnE*q0*t%}G>8f`b9)r+_tX?u7X1V<6X1UmH zmIbO=s_Yl8bDISR;*(wZot@zodS2SbQm24E*cqQt_D&blJ^+Y~Wh6`W{pY3XX{E{? zoav>$>Xw=$f!9X6b^Q-X;1!Tx;zp@bGV`+kR^~I2d805SWzs-uwKt-{8f8CvpS171 z>UgqMlPK&R^nvoR2}fAZhLVG3|aj6W*> zHvg^sb5eCQaC-*HH`6#zjE4&veHEDo%m`pke06*cmT=$nO#mGT^Fxsr{OK z#*jgQ%Ah`e4ql{Xijl@;aQm+PFZKTCTazvC&HtzWt^Dst{tk5+y&aFQMn7qJ)#gLp z?ieW@F)6O3e$@rBk?aDp{>;!ObOE`({TBk+1#I(r`#17gl^I%r&uTj=Nu-BEPrAJ} zSK@$}E8i0tciz(YHoQ0v*v$92P^laVHXpz>yy34j?cNLUp)PlA7#8i=VzM?fyCs$Z z0a|?2r`fOK=0m6wLb&wsp3OzD< z2-m?R?jZUl-iUfZ&y=ioWorzx+M-Np2&sA`8xXhJPH@W^$*QYh)n-m;wuDO6j}h8R zLZ#}*2yHE)QuSkmwvkY&`Y}S=NvKr)7@^vXRMo$MF%s^j4dn$hH_Ca5ip$S8TGqCh zA@>b$H5x2<4@oHv?s)|Q2ppXJhJt{yqd#r9JC=h>Q?v47h)5O3kx{VRRxaiOny<88 zxtJThUWc^C1^F9SC-eK>lF8^QEM_s2D_w=ijP|z8)TM)&MHZoFIXbn-QocFHS&?4~ z7z2^KtKL3&1k3d*C6WpW(LOXrmdQY-zh~+m?Dtu5s3^Ni1N7V9J$b~960H3K>!I`} zwt*<|Gr8Z!G5#lf2|kt73jws${y9Oe)!1zURSbKc#05uQZ)a}Q^*gI!wN{5x zBMYjLn#r?jeQS{d2FELFsWp&=f%28+thTZ-D|0bS<54b#_XN;Pbdv<&02jE4z&Q%| zv#lb4#_SaYQXMb(k464usaoVjfKYf0Q$DRn>At83jQCu2VQ7luOMe1XjPxZ>U$PBG zn-V&s?Gg_&iPxV#4zn2j9G|jV6X!bdd3I%u-s3H}IWoF1{fSJkRhBTha$fs}9(|Nl z;8>15`!W|XRDW{mRER+&USl~grlkINhLHeqY|8u(MZTSzkbfz3*|5B>uLVxdiDkBN z-$wgEDaTh0RSLvtUlmNixg3HV4V6Z;-!FQ@Gmmp6;c$rxHB#FQ1GmZcd*Trp_d?$n zGfb9#vSPyuFlJwPe@nn*G*US;0*G)3$_T5rpGK$2%%=w2@A%nVc#HxFx5Eq8Q7`Vb zeswUqYp9f3VVB_r2d1J|^uL)n_4CQ2-NSf1|14e! zL1d>HLL1|L_X}cUSCL#Ua0MA36Bv`?HxL7|tFO`0j1qb`(OPoAD-OzmYwcl(;##2% ziM9-MzFyEBfpe84MusQFTRT;fjySAPg#3dD@z0&gsfIO56Z0f5B{|)RyhL)k-N`F7 z1Ets7x5y``t5nb&$xo;Fo802BlsFaW`DekW5;(Hxc6+ER;>dcXt0YuqwNE^lD%rSK zn&Lsygz;;)eI8e=`!;e>G=kg!mde)XmY5=6N`xy-^hkw;u6B$3qd$e~RW7a%5{SkL zT`JWJ%O~3Ud=_JecowS#xT*1X}M~VO&kdC;vb8W5wx9{XipK+&WR?3aVe)c-UlvOvFFYqgd&GH zBaBaVvy?8v{c{9Pc7alk771VwUuRlH{vJG$#H~ z>f&Vg%^^UxI+z);M4dNq4+EEbA)5*Ly%+K#AwTs({tQU`ZZs}|>>oLS8UL{ZaT#Hl z(MG$`&C!dfjQ89d}d7$=``c*!K=xb^%sHhAOQ({vM7 z-VF#SqTYTT2)OYohcdev2%5Y!h)WE+e(=M8y=?3!!yIHIY-U#AeFJVB{Ug4;c}>P` zobB=JgE(yv_Ow&ZR6PF<6RW!bpMkWK@b0GTj`tSW^?3>DT-g7`^G@K`3i$MfTrv{B zj?RB;ZklbWQWFm4 zH?4NLr8;e5Ijq01r5c^L3_E~ly-1048BXDi!yXn67mTh>VAAka1*|^Jo&7uh?x-9e zgHDEW9Czu!NB0KcgSRf_ci zJS}L>guk1Q<)H5;b_oW=pxUhSpa-C{{sNDD#m&Ieh#trJGWTeDPv*J{T5>s>zS7=% zm4n2`&IEzk>K(!74TLcA(-PTp-ir1P&Hbs2i~j-9C(C-1;mUs{b@BEunUB@3eFqM2 zT%rY60le6N{sZVuY1~@I*RAZ&av33p2+C)rIXH*zB8tSmg889A4p|p9QQN=6Nt!HA z+(v}!av*5-Z`X!7X(e?`UXmf{k^dW7rco`MCQ%bKF|TUyrsD>;rZT8?a+3&Z)-2z#(-0k`5(H{Fx<7idz&dxua#p*DZ}6 z#T8$*Fn&~AaqtYIQ&B}zD??MaNF{o%1jB3^x3=QzRz_FEI>YFQSS^h9h}F`_sXGC) zrZ~w+KkrBUa6IrKc+XhMKWQ%Vzwboa}c2)OSN9wh~+C8Je%g=|$x}SrG%x+&~6G7<59Fe21u+e21u; ze23)kzI*&qMQW689qaBbn7jTvuW9Xr(w=r_q$`1JPwFmQuL; zfb<7H0icE~EBFeSN_}D57B~kA-@GN(-I-Z*xpE=D0@kgWIq(DpeUrFF#=vR7z(E6C z08dk}02s?NY~qiK{w(@WUs?7?DLv6ex-pR}y@o-EBfL0%2trQxNSitz$^K;hM$&uB z-K5BSN~~6r8BULe<^^!$g|F{c48}@Sh$_T4^_q{fiVH6(GzR&sn+mgh@bgj_v_geB zeQ~(+K(q6u<{|wjZ;vf59Cd0==-j3{+)sde*mjrMZhrozHNnC)Wy=yLE6m#}%(DY# zVc(eJB~A#{`RC&6-rp?R3f|su#lm(Ns90W`^Xj!;xS~wY)p`e)!hJ{uZoCMXYm3cS zbo1fGB4aIIiU)i^RO!~-BG$Ysm_*GKR=m#P<@}bwyhITcb&}ZaHMdkC^P40d z>De2P0UhQ+ywN$*9MRC%Bf4#p@^LV zl09ab(N#8awX)AW5j`A*?;SHr2%L|}E^$>9(^=}(yNvI&(=x0AjI9J zNM2@_-Cxb;S6t5dxZep9y;gkZoeB_blBy&~Xn-XbF|MKh0*YUw2k{kPj5bUOLv zZu>8iY+j6My0bNL`+}me>?)Q54>mXj9m-2U&;cAIl)X3wH_nH!1@#cwf=7H&QPqHV zi#5!|FYH%Y8ni&mUu|qk34!eY@MBs@Wv%^Lest&uaKss!6 zD@JFB?X{-^#17jlL2f-l1KsvO-5l~Z;E+LAg6~7P9WV#w!Ps$1!2F98$1>1qD^MMj z(+@?f?jO_#S&+l>53d#S!q-7_6=)D=2jtG(jy(MO#wza0p^S^t&9GRaM`92|Vg}@g z>~L16j6{~oJ6r&Sq&2b|>(L(JB77Ie_GT4Ve4JUb_=RG8qDUPN{^4%Md>*3j4Bwm> z#%6eygcs*CFmWbg5+EPAuIC>k7;64QB3XA}V1oi+nz_#FosMI*^+wUyg6%v2+{A4l zSJ;2($K&x>prH5H+o!W#KrBU+VR z8sk=!Go$Us;PL$RK+Qe_StjM>*7jAf`EydtmZ<&Skc92dWQvJQu@5LUlZTF?H+cO3 zy|D+h$U?LQ7HoZVXyPeBYcVlC#d-_wso>qiPPBtRp7p3;y&Xp0!DuNgus*iu;T^~0 z-DEr9EtYFR%>1|p+h@S76=wGL?RBVtM|V_=RI6oGH3)CK&cK|4#U|XaHfwZLA?d#) z9sdQNP64A0ny}5vlw>(M3yoRd>A@x z6|azxBb-$63PO)8!>b-$#dvoAWpWSR<)~bhJ^rrBCTATn^! zQyP+)Pm7#^9*FbU21or9EFNwYS>4nnB`G%;*(DCP^srI63sY_U5dJAaswZd&%`2@4 zH!}~jTu4eXotkm`j;CbGT-d@Lf{}bonZTnL=Tdkg1wHoCbh5o$Uc#1c$X^RBm|Og#Yv ziIg;z3tSU7LPTjmRdsVYztwnz$4!dON(koobTEc2^)rWutMbyj!+3;c)J2#PD-npU zl4glIlK7J>2n}qFhBbHGo-As!RgCQ~{04rIQ`P7srSwX)ODhenJ(s9jk!ry>QlY*` zDIloDd^kQ&Ac~!hbsj{qS={J}E@wi}h|{qY>bm?00Wc9q0Ff01lE}vZ?s0&iPp1Zq zX7|K`p8l~S7!SaLumEmZx5nlyk(3z29bUp=h71mrxAfj$%=uAb7#go05p~{b^wAN$ z33^Bd&Av$OfAeM%%@^IlD6Yd6C5qziOTW3n{_MisjG`ryM<5!Z?mA%B6v5472s@fl zVoHbMF*?|rZ@oo}l3A#V4|8i;>^fw@|T ztU|3rpfDGoB?I#X*hlM7QkYL@AAuGLbOfPAgpLsC1cA;XbONEX^zhyaOhH+oJm^Uv z7U2Gn1G~7MmiP_$-*zCQH)tK&79toPcWR9f0=RkSf}zo@*1^oLz)u6cH~TXW^lkL= zvtn&U$G(d@_Cb8q-)PV?ch+WREQzvTU>ag{Hg{%hSS+7KD>5O4us5jPl9#@X&K-|M zm5rD{*J8Fa&W$fX%ed{qaO6{@Jp`#l(r7DU=v77y-3UryFYywZEwq+_e{0-exgHZ2 zqI_L(cVW|s#-$9vrbBdSlZ#1hWhdg7k$7yW9vuey5gMs2$!mgxJ;61x2(%@HISkt# z6jEbTyN$WQQ@Cw8mprW$M!{}Z5Eo+Mc;Ro5TebW&nAZrUkuvDex z10Y;m$g5gg=mLFogi2*Hl@e76X%y|cG7zl7xBaIJ)YSdn`FL9W{(P9x)!JeWK&(s& zqj-copNEIiX*Zb2UV9%->+pHKM9#j2#j4eVae4q=s1~f_NNAOlIpdV$A7Z2h1Q~FH6Oh)xYN;HL%BZ7T8;9i? z-4uIE%Z4hw_{sQ(+Nuj=6)#MS^d7Q`f3EVQY%uU#3P8Z9QTki8Gl|YFX8WdLbDWjQ zDyO^m9QyvKfy2HY)g4V@LB z!HL!0U-N#8zOlYrg}+&CbBp`8?ErN^cuf|geg-t`moas%gn$AiG$htus`$~W_$Tmq zp0+CX?QZeu@|#DW?w3YySNjzk{af_uPe_Ds(Wf7>u;81WW8eJ;42q;m-Stm@HPrKt zK7H*$6m^t7{ZT-Z{+vZ0IfAP&D|;FX78U~<#@)o9S19&kRiN@9t0Jt6a^Z3wf=G6s zB$9*j8V8M)t&zK?*w>?5IeLHETL|n1A^?8Eo-YH4Q$JP2>T_-A@FX(B8&tCl z$5hES!Tg`yBU${AoW>z=4H><;ArPH2D-fNZ!(AgZ&6N%+vr#U_-arp3V-zYL6kY=) z>0cP_VP(I@_|h21D*rLbjnzMH`7cQ!O?KniQvT}3R8zbO5Xb)YL@li;OhA(IhNpjM z##Lkoq66@3cZr~O4OSB!TLq%ev=VZOUW1A0A@v@vK{EwfKy1TKL_MtyeSjqQvxr~veqE@^&289HEjH)m z7FVq13O_@u?2DPQ#PqEzf&QboVt(t4kRG(2?SsH#^Idr0Hd^EC=GZSgLREmXnz_YG zhU6@UI)Qiao->pjVJ*tHFO%+uSG--Ykh5=}m4!SLK5Rhzf9!n=coap}_JkxD6zGT` z!5cxM#ycn|0mY0Y(4&dMDw^E|1rfwg#RxNyRlvYxfVLgY=apSWalNs-y34MDkrhY) zGr?<+Rq+OR!yd;=6a`cy|NEZmp6;0hR{zi4f4~26o+qj5s#8^`PMtbcr*5a=Q<%#A z+|s_;LnSd_uI54mPHlZq0#Vip7+56$M!-7^z++*kPR#0uFyjpzJf^{0d{-ZZYDNcc zUY6@yL9`jx88F&%6dAL|tLQIbIyM>oDGqKS$!*LQ*MlU<8w{gGft}VoMK~<>6XALR zK6CddQWbX#5sCTU=`OlAU59K~vUR8A5i2o1vp$B>i6YK*;)u$0M7zm;likg?0tEJ1 zmmu7)J@pk~{)TjA(SgG}=(5xyg2cejhS`)M=rO7^Gqlc{iBwMQ2;NzNuP6Bab_I7$ zVFhC__iUA?fxm+&)xKxj?dvq|4PT}`zz##~fpp84Syz-m;v z`D6h(rhLN8g3k7KKNR6+B)}GYD>mc*jJo^7t+?gRn;%%h!ZmkwtGC?vu$1qmUW0IX z&H-Cg;NOx0FmOHUSa1DdM6!<4!9wWxb{&^q13Kasm+l^P43FodZChh+^(v7_R^Rrt*5|2ElAxCQf9FCCdJ<9NVPnYhVvfHv^V# zlxSEP8`%3Thp)~=k#;J+UEYjM#HK{2<~Wyncv2e7a0oyY$$}*T^IjpBU7tGOQ)d~& zp;be#gW)-h0*C*;g$>Jd0u*U?kX!j|`W|xpOIM>6qxTBVH1rT1cre)*dmcXPZ;0b+ zl2${_57V<|>+>TqKmJW1dMVBqs3Qk)gsAI+%{+2|tAc1$ta?T#Hmu4=GEDr+jBl;i z`tsyK$(g)$+1}xA^hGX|o@Ez_2b34fxrb(JCJS&d^}r>#M2)a{z?`j+OJ_vRXm_t>sj1K(O8wdKV5KHO5 zrQAFTY3p&SgwiHY@Bu;a-Y@Z4W1UAZz7%~;ea2frAXJOoSbHtPh|Eys7m}er1vCIV(s^ClKWGVyfN8rA&_`Unenl8)a6c9h^JPwE0roDNPhW=BS^f= zaHw0%pky)er6i(T358L<3)&?KN}d@3jL>_>`t*kPJAkK`=$U!MoFBb){63|40(y(tr+kmkw2op`TJZ(Yme!I#b$6MU|wKJ>O~so*dVp`}`L6YW*2 z#GfSi_}*TE--Emr5=T1a#h-<+u+NhO%=7cKr*H~$BkGc6mi5ZwvkNs@q=zxOmN&J& zlh#hki{EF1BTI=f4iQZ97mdi*<{d1Ydw!l-(kn|hN*6|pTf@6fhtSsM^Z6&;Jh&`+ zLND#9&b>;^Gj75zMh0cVgseGwMpNrnavX(*hh>-jx8gdMU2YEb$c^w3-XU-0B&TPv z9|cFG6KnLx?GdXdwyH6&ql_DX?1VdIMl}W5Q6iynN91EHt8HB~sc4Nh_cg2o`KzBP z;D(Yfc!b?F7jm3eqyLUj4@@{eilemLz?^lQX2gT|rzW4C!TYhZl7sithl>QX<^1-E zs^|dBpqiP~97@c~GjmGJCo{P*<`3^_4UN(>U^6I$PR%*1)$b7CZVvnnN@Z0JmCqa* z$1w1=jvC}QWDmxge`v0+R9gj8Jx?$%P!r=)9w~+q^!C9Ro6xyQ2J0GNAxHg2S+ISZ zo0lWtqbxI+n-ku)Ec{ZA0UzfAv6>v_)lUG%F4oN_SZNOUw+bGzH)m&6VqBh!)jS-% z3s`<_)oaEblGY|;iIFp`ejC!sOWDcd|)RPeIcU{ zX68pBdNrHJI);E|m*+sW5RIdkHh}X;77krvUWY+% zoDFt{fK96Hva7X~f0@`)cKj#fn{QU}y(;>>7QK{zKLnOALwC0S=j8Ka zT;`QtZtD7om~g*j5D%D~;OZM2rje+v#mVD z!WN-eH0#gN#-rb-+Bf@5+6$K5;kx+^wXKG7oq#zWV6QdR11kN9o4cNYm+AeKJ6Huf zAbDIgq=#?F$(}j|T3PUNvk3DB>v~+Whw)4ZF|#U*0ar@E@GJ?z;e|cc#VQ1H1TdJX z?6FE!2+s2$1iJSg>r@qzix4a!!FKfUJh8`#1y;P@X> z=ZOhFHs1KfHetx2iIer{vVI8BVX%Xa92Ou|4t9tgm9=#0z`HP3n^GWl0>Ova`jD+V z>_n@tJjp1sP<_d^E%u}N6^*DuB1`avO~$1R#0Io{JzP%*)*RvV-_ie-{_8pA{hjP8 zt{jIvF#*A@BB_Fx%B(pOA@}|O#{s1k@`U|(249KCrXe$@){!9VnbBr`hrhuy@>LY| z<}xAyI17&2lWalOAdL@Yku)Hy+E0{SB|yp+VB6gutZ@}!{gb;rf~Ow6lQ}(&d|RzI z>-S(!hTm$hfSFr8dQe~u{A2(HnWS0K7X@06<9Ztq6HM(Zc)soe`k@CD4@f~e6I8*h z;_zo}I0#p}CW3$dT{ZKySF<4s-3}gfHDb4MEGEt|PNvl1La=uesf|5xwn9`+A6O^i z0RXnx$4K(;sz%Z3b{Z%MVxocOp6WKx;jBhyR0E7KjvS6Tj(Kx7&-{hoT^3%SW2g_C z^Pnx-EjXx~7JS4_05+f|z zk6GG0lEz%b1m+;{{PWGNtww}>!cGFIh2SR<%;}TL#;nRg*kTET(I&|nk_%xsOBnW2 z?XX;gRUr)9I_#8`_BdE3{nV6}0+*{USYmurYFMSl7p)snkgWL#qS(?$LYa_ZOO$zp zcXia}PC-4(qRSQ_fRnuvEIK;L8dyIY7TfGhQq(Z@jX2jz{|!ulPTFb>SlJE}TzjB2 z+&%qWCOC-=x8JX^(uz}2P6NMw22fTltK^pTAyHR%l5N>Eff@s36JP$LSlb8}gcV_H zOGP;@jq$9HvkjTOXA1?sI-z-}RY`R06Dry7yHTMJu>i;ISM+_)_UqGZ10LjoCFh#4 z9Co5-w)SIH24+c(x||PZ1)o8+?#|`RCsBr_9a~m~PDpWMc`BRFVx-=IQLMlUdfc>ehs9vSM0~e@8%cBV0FI)yUzeRnnxk}^si5y zk5r$rpAQ$%TkCmI{Y%_)p*3vJe8rhx$a?F@fbo662m$xeP#4N`1F=#aZGeT_(qh{k zWV_Tm7=D!P=G$%_U4N`}q%vk(T4{$*w%u{ITR|6aRSGV$kl*+PVv$@HQkaH&+r5u72;I=*f66f>w@s2|~$@*AU3~Jb?2u0dr+7 z^8`e0nR$%$3q&EG^2i6FmVgOjqC>0bZ0j^8i_WTm)vn3O1bz0AARBQ2F2;#en8?NT zA?Lh{ZuYjU&Wd@lnuwBSk!@I%J)3?Gv6QHf?9YyqsTBy%EU5HpHPq^8IZ0~NGijf+ zx21dW!=b>*L@r=n2ouVYSMangQN?K+qdB}4bK!3?r*-PT9s^sbA~9V*c8yqcOYZLl z@ZN3(PG`NO@{o^`mvU0Ra#OzY_yrco;`sDY2z$@~9A_u0BwVH6Jg>@+sb3Wf zJwFgVZ*m|SESNk=tE@i{cE@MeV}<~u>oY-z=*1XHzr~3_Wy(qybB8!x+oxF}Xbf1R z$NW-FJ%$cK?%Sbbcb=mMn9rj1&hqFgax0fu=@QKoxK=NL#xn(ETI=s%1Ds738aXC= zZA-oZbDjdNQAx~sOc5|@Bqd^1FRUpLH#S1@!1c@=K!NFmzkx$NzkmbXBn}b?9GVbl zoxV>T6ljg4N1;qX9K8qaM+4K>xoYLqJsjhk@UcUDTsr( z<~+;(6t{gGIL=<;zf_F|>Eppg=zDtt<|+p}*xFjftgRz}6vFG_C)NySwXKdSe2FKV zO=EqQBk;9$c(+Nlln0v-%E3&@gH_dt4aDZr;g1<-TTe>L+0s`J_29?!3sch1PWAwm z@_LoBm|q7OdP0TIIfdOuq%+QMcTf&#jxZL_J87MDM(wDWl66YTdMHPwS-cN`cU7 zm{NOcnF6?T3E((P&%0i!jZ~)aym>xKvn$N^jQQdH1P&7E@a14Y3qLeyy ziOZwWSL3w>X!OiUY4kaNrLMqlrO`8UYgjfqWpv=gqeWL>nib?e>#g%}V8TIoCBv=3 zSupBqF5|KTCdd+WXFvGO?5_Vv&iAqB&EzwY?N44KrEz;|blTE(YIGgYM2)5%B{gE2 z75PM|ld2IL1n4u|nw%*$svu46ptUDUjn3HU)+llkln_|4<#R(|Q;({GC7{V@%5w8s zGD#j=F*+6(>MzBBd}}^F%cGAn6ph3t*Pg;bd8``23lTBHzltiHY#}Eg>-h7`CnUYU z^`+LeB^h7p6JF7y!P>(DLvAfZe!+b6VB0^(tZ{zRHY; zEjV6$=S%g6%olWO!gxZNI0Ofiv(K+Eo-a8zG09le%v7<+D{wM=M&uuGwWn0SiA6Ty z3uT~-osTZY%QnWHC!o0k=EdmQH?e19o(v!>TF=LS#qT#7ON{!~CTx6Z^H=k{MYPLh z5C_R^E_AdK!hESmqfJcQJYDrVuIH!nXbYmbj)pRc2bU+wEr#?%kdi$HhcTqrNsJlI zlOTH?P5POwJaRFOrQPu5+|y_kWG5z5~r@W9Z=xjt*+xmlREe`2mAVXQ|_ zWlLb|>2cNhw^-kI;G~&mler&yI-un=k8Fw$Y(gKl`XUUUd{?W=NA3` zVcZAhn(N~r3RWd?;i)f31rmyth3%L%$6MLGacG>R2*;q?ZnLfh9`Rr%pXeuEps~-4 zuwlZxj@N1?V2THW5aC^?Xf+qZed0KqPaX3)`pD$1e*mI2JCAKRj~|6ar47|gn#mO!oq?%p4<(F^~U z*?)cY%>BQ|#Oh;&z`F`S$aAB(+;2FG4P7D%LRNhCcyn_$NWC=K> zr2qS#Zie+j3REi##X5p*!zY+2FHiD~Efl7n;`8xQfd2*+z>h5`JTPSbE;zy7+$=yY z*leIE)eSytk`o9EP;TNNlvmGin{av|a~M%kqCNFE1@d{(g2M8mD|lrHU(*h!j4)+v zfT)1{w08CuO2_|>!f-n9YP8eu;jMWqc;h5oRo80nz*i}xG^b)X;5sMJ@F5U=@}FQ(Xwnz3!m5K z9*+&s_~Y0D_}7mRm5;X5QUCOvmOesU@Bv1MVWnB$%WLiQU>5-Ef!WM9_izW_fp2?|-08n?M^^sjG~Hy>`NReF$IK+i+2mG7Zd9v_xvp93z}5l_73Q*; zAT@`w42M|Bxy}bR&CdC^(Cm?i+M(IIsLhI_gl3CG!pd;+=wYb$^s`ZKV+$Ga`JEcf zpFz(5>s!{>9+pFhWnns&iw*~t&3?hsTt=~I9Y#dwgPnh3M3Fa@5TTGgb-eh&cF1`f z%3r}XEqmZrqw}&ufaozmH2w+L(;nF3eK9M+nk6?<=3@F5FkT2We9|G%x=x?-&F{tC54@29UODwAH#Up&xG zHKW82*Va<2c|{)3JQ8TeKSEpm#4XScYELb02emK10&3unRMfWi1Zwk#0yTM77niD$ zAAoGx4rPe}RtS$Kal#lOx27zJu$})$su?JoPTHOKw}byF#Q&Id{NH~YQa*Mj@V^<7 z)SbBH#ozi8`G(hLpqB;n9i>fg(!Hsj`tDlXQ-#=h7MInCa^A_!&Nw_Ma_7IT8j(dEx>qu3(_)3cC&=+&RN z;oD){J&W3D_@Xb-@X#Yu8TaxYVBD96B*&?~UjPb|bXzOBn9+YhwCKl*ZqRzUVuB5D zTTvwG*q9{UHzXY%x=^G;L-veQG;@O`*^oBrq!Hykae;4-bZot0ZtJ~j3;q&_?iEdY z(3NcA%!dx6QK~OEB;SCW0Om@fXhm+?(Q4#9kx^?;DSJSxfpQUf5GFC>cvZmR^y(YO z;<3{POoyv)9OEjoFCzd)cJso!GPHT`;sYxN1@V<&>Yum`+Y$eR?@hL0nVQfC`79OJ zZmcOSXrwk%j%{zE4`;%L5J$Er(2f`gY+d(Ln8;JN5M(%bkC1O5EPfxf6WkKbH80Ad z>iMQftYzasJAct@TBHX0=D)tG=iig8s$0jKK1UtfjC7k10zdW!=A0Iof~Zyb86YuF zv|08eg6xKza0avHL(te;|1FIc`CU6TsV9DIYSNu(js}{j2`7ku{1i~o$L(53^l6@2 z?2lTA`f(y^5--BrwP40vyF)yYVUEZ$BAh4NoPK;?#pzGC0J;=QI6rYSqNMcUX2EaU zsr*`23q3eh>cnzU`HIt_>dD-SGnPMo0>DF(_5TAQP6LFzf{k&-(dwt-l%2C2((4PJ zc;s3@Yts`M;awe^6_2@{(W8Fi8n@F&?^@VSjW@6&s=4ji?!dwWQJE`GLtEPuV4HK7 zCjiP#EhjuW&`;2z0QIV)UGvb0N1!FKtibi>K#?rQ2M;xWv)g*0k6JLH!DoBzTWS3D zwzmI9sMJ}GI9_&%?6r-}iC7_rG~bbM3BY{C8t}0cafGJ`^cbJD9AMZavbR*2uhm0=W_Um) zM-!kRP(|6XpV=r_o8yve+*3G)5T7*;pkUO6SWmD)z|ywi=_b1cG5?8wnN?{ zRfX0aAmnA56&NIa){0Zp$vaLOVx?rO$a@!Iq67PR(h4zVOSnLiysuh9hy@-n=u$rG zVt~2iWxm#O1$wbMlPTCx7qm_QC}@`Rt>LTVAwRPo_(*7GdBBb&A^HLg zTTR+i+rc}`)(R`gcRi4h2tMnZ{$A<|XoUiOXa;u>CACZntd{@^>Q>2)s)WZg@OZi$ z%8nd^2EY=k?Co;m<;S^P>M+?*6mWg$;NZEqAXU`)9ftFGZsh&LCN5$g#a)` zR}Yx?FUAKBUFe1^VCZ-l4FiH98#uw^z0_o zwqUCRM%Y7%X#wM@857gVM^MSne$8BhAzULSb)bV6oY&frz zBM?(#=di>4r3`7Uui9_Bt{qpO=)p5~8{*-u8G5HC3EHkz)R#r4;8MXGh%h#(DA1-% z?Il)qBiKfqkjTB2Erx2}$dG0vd?gtgylT7l%MIE|%~LPKOfq2NK1J3yvLEy*P!B}s zFG13Pc{d&1I5=QDrF;OwRdBM#OMv4cE1URQ&E*(FKs9YHuccF;Bjw_w@PYN2dNdcF z4L=mGcHv#aWp((RiuWqcZ3SO}@P6&ib%~CC4sX6dr*+%4OB$?BAlP;-x5ucWZg>K@ zX}dP&In?8X23_`K09dW}Z`xj_ozSA4w5CiO)>2;dRk=3os{r0G4~_S)0)Ak4DcL3s zrq-l=plGu;-$X3#(i3N(q|N2-j~*R{gCU#nqPV?vY^vr!br<}F@E6xh6U0~GBY^k9 z$|5ax3BhAHA^-9{jG(w2s9M4)PH`_vozW|Cb6OlwnHS(bQ$0TMTm==C76t_^FbmdzJma4-&*cbJ-|w>Ih8%BDGA)B`r$;I9Kd zK7HfX^h!3CX=k^908Grzuy35g_-tiN8Lcb3VKnt83rPUlHXZNwg)Kxe71zLrErN+c8wKeQFO7Vt~>>kN< zDu~^u$YfBP=fZJ}1-^vF{h{*AYm0FNfdTgHY!cqW#uu8zB1v#r2VZ_uPTw5c&=Aj> zWJGHPU<4K<>Vv(o%TS2vFSBTEcILjPZ-ze5AMZ3~SN_#K%TY4`!SS*00FUUIhv7;s zhMGTjpwp!XzE<3W5-mSi5z$$h5`C+R-Va|Z3eZT_kt+IjmAXBeDoVDQ$+_= z^e7d5*nWr}&FBx%e#m^Ziatd}|DCD(GWuB+eVU3sNJTHk*NSZ{`wH3A($V` z=yw=BUq$cA63ky!(Ont6nbDI~^cyOAxr!do=>R{TB%zI9NqrK%(-Bh4mt%v6%&{d1yxKG5OqL zE!d1+CRZEPv{w^*d~uE>fVL+d(8JMe@o_1Ep=oiBB#Bd)t34Iib^v?!7V8uzS47CP z>P0)EmnTA|vrpO)J}1I1GSnk3W@}v>YTiXPfWDln`g99xv&CBfP7?hVR10e;cL6HC zoS=f1978(aF615u8feM!s?+R6XQK!{Sp@>&Q263h9=HP3{DL4#2lO` zN)#rJP88VYu_W){QD{3^JnE08X4`dn+ip9whHN@7>7=;ltG5_2srFV#k!@RATMxoi z@OX$7{vCk78!+)6gRn2(Zf)I-??>PIVSg7v$>HA*h3~KxHhR+jn4Wmu3%qvWkN7am z!6gfLIpug==96Bo_dG-TdCg5=5x?=W-}r}|m;D}Mw$o$o!A&!ikJ+7lma%vb=;mJB z#Hp%$h8XHjrDH9bY zDOF878q;?iM%#%4kl+J0?vvt28(rb7&b?mLOn~0rsanE$}5{*{>6H`Qc3Va7*vw_&}iK} zlqb;}6X)_goSmL)?AVRjP*&6sI+gihdtw?imjggGJHe}oL&}Zja!e#s@rq2w>_f+% z70iFyj4xLLV-d=D;K}2JyeSOEZ>D449JG%UN{kt85&)O+<+yM3PUfT-e^`W!&u_)} zGJwoR1A*~>*D6fGG_tp89o&~ZEmrEdgn9*<3ScumU^t29!+TBSolQ2RRi8!dvWu2D zykmui3h%IK<+!{a9hPerXJPJj9278fSe`MwbGW{DgOxqW7~Y}(TS)!gqsi34HP$sm z@TaDY?|b0srOh!l?a<~jRq5GEC@_tp&9{AoHVhzb&V5~IbFBwVF3xTQm?@@$K^_9f z-v)Uxf$J!c1Fzdfns@1juN9j(&>WoEAtMg$_xasX7hQCQfi;WWbTut7p;ZN%y|$ z4mfN>>-0>Ngov<2fSuj*wkh%$_xJXcm_y6WDLGKB)iEqA6hOs_Yc+hEsNC3HUi7`{ zRl5Q^zYaibi*CP_^JnZ%u{QFFvZfuxn@nyyh(Bi>d)We2DGx}#L zyb*``4htVje@C6GPTC&Oj(e3V`g!@mQyl&L*mC2efY}wIL+R&hQ9}Gx{7X^l&&vNHG?r5sQ<0;D&3+HLg~h1Rl~jr6nzzd(oOBRtdz&dr{rL92+d{%3)0#PN|{p) z8lHsKbwFZdpij&V4#lBW=LXD+u)1+jz_=v$9D@rEnQUQ5blm7t91+ymq`11Fnv|Eh zY@N8HZsY}8L4Q2R#KU#Y`>nV#`YG=kX)Uc5pKv0xS!0oj_hyhE-{r=PoN_G6;Fbd}I|gu0dfJKVvg5Qkb*uD?qFtDW zeZwwJ-4S(`n@#Th#h?6sQ#oEr#`DNp4c{~lL}%odo995@wFJAB7kx1`S7rAzeawjo~v@g(wVXB-ef-;3Sv?R$T?Px@XrI)FLS zW$$mA6?@&x)Etugu^5G{2MKZ`9$On&iLTT%C3T7;K_!!u!z z8|*0Q@Xlfs-{`kkbedF)9mXuay;Sm-J*{UCDd{_T+Tmx1XZFqWg?iBK>vSNGVzwUpijh)A6#W)fu4>}d7#`MZEaMm18KpJ?<2hHZS=xOs$8~IIps$YYEGNIUxDwcEM`U`mc zxXPU*S_=Y5YFwBH#R6t|4vmJwvSCqoEOtD?SQ;@j%QCXcuKJ>~JYySe3zp!pFRSnN zFUYC0@F<KsUGiKx>SaFJ9K> z4oXt5tr10BrO9t&7DxJjxV30nZ@ms_@oUM@wFh@i)AR{=NutXG_w+<3$ZAkFNwM;` zlQYJFHJYx zZaiz0HyNYX8M9zd5iij4tlDbGO#f;iSzTsav(($ZC6QT8S`8P!z=+KzxLK=NfG=60 zEr*U50ONeAH@ugH*Nck=9H>ROPXOLI5WI6>mVVWS%CZbt+M`uX;h*PH@z)zZ2LC*# zZ}?Wf>dVT~qM3?+HsCI<%Rd`z{&|j}FP06NSQoswJbHCOfjRaC$48lAWgV>5y26ZB+TDE{m;MQa~N%>W|L|m)WMJKA3eWyX-4>)?5RhDW8a2bPnpqO zF?>e-em;nvjhv2;T}x94N*=eq9B$3lZcBcLV_U+l2hHeOca|>)3EIGiV{e38yGR0& z_u-Frhgv&{(a`!Xbr6^V&ZQ8PmzZL{ zejsgp4gU47kHek|n9l>k#mtxwx1cyN#B6t1POS8+G_x*480UwutUvr*EVl9~oU zk|z9y#LB0e;|X@`Tuxczr=;ijqNKqMJ1-VEzN>On<;ka;qnu79j#OphTL~M5$r>>0 z!#E%k|C1-+4g@$A@YF6$n3#{1jo;+~pO^~nRBY}sU}BVk2g$cs892k`$SpE0XOHdeTliPb2VRWY|}a5B=s2kG3Bd^>_F$U)EAixqt76T?rZ05Gw>Zd4P$4eOMGlDy9>@?!)pj6xtZ zgg@F7ZtbAmS)bnoS>fuBSU(JZQj7`XsyjJF#B8k80yTkfKCtjb=V3bpSzJ85PjvWq z;a$ULoPy!?GsGnC`a&cOzP+a}aXcbqf5v(177-8JiimD=8htn#7~a!iS{1^+z6E2m zfyq-8Plg*~o59}{lShD3I_47CAWb(u+Sf*HNT~(mqt_(gwK~8J4_!>fE4;4QUMtH! z=D$($LKJr&J-5QsgGkPUr*myjU;KLM5!u!BPf`A_02#kb`6mPMI8_1bXpk4W3xn~8 zJJ9?5`=M~&d=9nq{2}?j`%lXE=DRQdr~jAvcKc98vAHV;T z|0u(5v;Qy;Yvtd63ce0az4HND3lD$N&z_)~**Ukly|!pGY-!_ZRlR6S@FWP+d?+lz zb1}x|Lr&zQi@){X3K;!Ji*S@fhv_FBro3o+e(*wcEc8UNEQnm>*)(Ru9O7K{mo+fh z(A(TP3J*dtOTMgzu>=JW?AP#TPj?Fm-k+!h3%Wy8j8c1b;)R&Dvene!FA;wWM7JW92;NWASytK z&qsNwwCX=24ASh}n<%Mryz&y_W1xg~RPVvH&2LgleoHYs^R^#y9rzWttiocFsR+iI z((Exsv&)fx(jHUW{5z)PukhVdFZiC?F20BF8{g$f>(VDY)Q2&G#TN@begMAAe;@c> zl#;)~_dJDfX1n-)YLM!CrEkZS{K7*!$Yk|L;LH5?f$t-$z4TD{-iI(yVxwS|&JQd1 zjqgP%`GtpOXm|fO`ZE80;Jag0TYNu581Q|tU3{ba#`lqw{K7+Xek^^N|32^?o|3-N^f$v=@`73;HK^W*etX+Ih+&8|%Q}X-2;9usy z4}7;h(Bo7Bk^Va`@nZzO8yGp*$4xDpJ*4~Mf=A0w3Ph%3vJc<1ji%f`p?D- z=8xCZYF+zqm?0EmKf*jaE4-^yuoK_ZjZB2jr9E|ahp3Jtf9u2FWN7n$A!>0~?Wt2r z%mIIu=VUqrPv*U{$mxhO&(48Acs@2Jg1^G?NiEU`p-^$Sb$ip(xRHGzp~n0*3oEqw zWu3O$3C>}H(UL%|RALz3Y|UVTtr+y}49@3wGrq&ucg_us$DQcVR!kJOBHH4ru$)#B zeQLAiC+tHA#7l`&puD_Ry2+ZjLi53l6EK`{6}BDtz;eJGvmf43E!hv(bflc^+H62> ztix%GqDg*jO5-F6=;tOqyG>GDGAD|Yv?)k>ACfu{1~TX2C7$=-`#!DK7@Px7-~o3m z#6`u>xAjNt`KZMldGC+YkJro8G~{KtqVA^7KfLSbY%?5cKZ);pK%rcI4>jiOsqccf zv_K2CUK_0a!&`g9ZW~Oo%z1yehPRp;!VO+0pGi8*jt1hY^Y_qs^Fy+%A1l)f%8Yo3BCyQ=hczcG)QVaYyC(c5@zQ44%g zV!YSzv9|M-@O#*+jae`IXm@9|n4>!xxeFWWmO1(vzj2`kEQ@JgMx zh_WjLDo-bBSVH>SlWKXu>Mk7fs0ed=;p-e9cx;GTEoX#_&_i^l`rAn(Wo&jM}=iE?8F_70@qoE$-+vnomgl@ zy=oSM>J1;~swnhA(#yk_O(V?5gfIQ!?^{FX*^CK0Ms@ZgZSxbTr#Y}!nD%8pxBf1l zUe@#*&w@4UtYemGv@i2%sqyC|Yc_n+TX^z4s}~-403WR5$rNJ2mdr+2c-A_HCBfmL z*OM%1?a2g7hF-v7t>F1cxv0d$k`43&hD3?5O=q>R0?~m(iHO6HGo9?x z84~wYqFqk8TG%o39cl0{j5ixT?j8P8cySmL8Zk)m+mUUO6Pvu8_~PC<(P(b4y7yl{ z=RKdV1=PU@3!s-E{IlS=zTWo(K#95J_t&fZVz;Nqf9Hssgm`fBd{llqwKBg z)c#KE3%a)A{ZsLZ(xKD7EbFt@znVAhcC6Jxy|J8Ft3x8fq+v#R^v2d;m!n$PzL9#w z1V6;?{{oM{+T-8o@xS2l=kWa?{8%ra$G^)1)8g@4 z9{*O`Pi7!|)+AEw8~CoA!m#fc&y4du8RvQYxwfCc^mnA^Ab5h3(}D0^8)8^@0y3vT z^w|DF+fM-c_a^|KqvDT&C&E9KC>;yW1=mzw&A^igK**6cB>lR_Uu^pcOh2|^Y6|@D zTrlH$$)S`0Of}htq<@_4XQ~SLJ4+45!WRlMgI~fot#bPLjK7qy<j{zd070ZCippu|)(k zgx0f|8I>7>aOU8!vZC)oaqf|0oC@OfHSFL`#*ytrFi;kSK|EvZl7LxLK(-7F!9(wG zryarriD4DUvkQj>irxvmnt+i32wYf?MFGK{nAqAeJg<-{W>J_DeOk@km;#CT`^94% z<8V&o#6ME%@=QC9_JMG$jQzw-mjIq)XGN_7K$k}!DO)X>1o4Ud+$2yRgzU&f)Jb*} zJB)va>MRK6E2D@Hb|IGRWY(1^h~c(6(HrutO29IW^#>kj`;JyRwqlpmF-RumydZHO zSp)2yM(h4Z$&IYSWVE^U7~)fTqUICqJ~MtK<8MZM3WL;av7-ku`Wi%&TWVghL-QGW zv7IQDb!wiqVR8s_s+}_OBtqlQ;Gerc>)40i=Xvv?nBxBn&YSbzihToPALq^g=0fqj zc|K&HbFK!X3sm|A z?WNC2O<$$b({a;(fK~(I(h^@w)mImM zm79;$;tOh9kP`Q2jYH!n56I+Y(CH^0kNev9{& z-%vZh(^B)RRr%3z^XsPatJ+t7pFN=JyA7_VzLQmcblm*b00ulYNX5}{;*@ncoV?oU zoV<#^`W&Yrt2UtpECUIXouOts)|3!a&zNfw<8}-!@;Tz-B^b)x{z3UUHh$OV2x~jO zbI+#Sc)1);^W()><9q8CcHe0BQX+mnC(d_2O5dL6QP3CyGg6V|B zB9`mj>UuZXULdwhyi|N5d6&v|Ws-fGwDt^h>b1%L=Akb*8uXt>^8Zn75FYq{R7w%6YnAuKijh@<#NY`s6i z39OxWp6jK4#2=E<3!OjWsQeK}qlHwKVob8 z5l+7OLjv9PQkUZo+0hFvKjJF+5nIQPOm-8Da}!j+O9emT==Tv#cUZRkjxeEflYC>QWbAiR)c#dpWB1=S{K``oAT^nJYh_LDzEu z^aDH;T4vmdB8t97F!#$>H?;)TVRMV;IzYJVL*a% zaIuAJ1h|_q_0`0owtmmW+dKBd4R|-QE^TAU(cU9O*;a5d=Ud6jSd;IC7>qv5n!^Yp z$-+5N4>kXSzOEzQnSYc=m$4xNoHoR=3fP!x0@YV#QjAFdj*ggv#HrszmlaAtRsllz z`bi+VC^rd`;ppmJL|0!#2KVm}<_35#TT|~0q}U;>`gIApdGvHvV=<#2Ks2f` z5`L7+K5m-_B?P;tb)!J6EQCK`E~|vY6S}{BiDSjG3i=t+cU~C>lqdJuBoH`vK)mb!IGTgU5zV$_=k5?e0z3Jm;NZjYvL*Qpw9nuymeSGC) zG^=&E!oh9ynggJcp+X}W+xlB+z$63Iw2DT(au6fmL!_wU+f`sb17B1rQW&G=BL$E{ zfXD1qk=GFz-;95$?Zxq1?8REA%;?CmIefj+e{>^LkA-z-8W9T@yWZsFA{OrFh8DWs zk?^hoH#deW7#Iul1v-3Z=-7Ps`7qxG?Ze{`h%%}P!jM?F%Jo*dUT2;Y3onqs>azg4 z#Es{a%+6q;>vd*ZvG7tiRkIu4I{u>Jyx~X(Go>O%@)gagF%)(>gk#4F=H-56~9p`#0Y%gdmKEZII z8(-^s7r5SP+Zzin7GL#Qjo~Hqp#kb$usYYf)b=)p>Fe4UehSXzlVagzaK}%Lh5yR$ zE2m9p3`;6xv;lkIH`ucxmuyj3~x!pUe1zo(q{83?Yur2z+|aFC`R{@J#_ zX_9s|UaY&(v;c(gwX<`RFiUNJ5@wfz`HKhUo^+TTHG93=1G69 zh)>Ge>c($!z0Iz-$@a#=miQ!99wfG1nOxVK<9dCrcbA)2i|ZZf0_d){*!2!_z5QHo zq3x~y`;`=C!MvNoli^tqz7SHt3||hv5grM@tV7|jGk(eS1f?&%hNq?XqAy|By}8_o ziNf?+06NnjfiUIrgnzltRQbuzIuj-&{9#(o`Hpyh)|oif5K=&sb-kRX@b|OM#cUZ)EtCTKT2oX5j>HaPa$=tr2J6&(hlp%ZPb_giN4ebed&GCm!K^*1uw_3m}Xya zZ2z~)qMQ8U9(Vsp{)t}1n+=>?A?LFD={9eVTOqC;@Agm>}2Ryd!WM4!~ z>P=Tl$;*`9^l*E6(+Gh`)tf%D#y5EMrk&O=s)Wc7z9JP&!PWf;kG|KkHLu z9WH&iD$LLNl_k zA-Plkbbabx$$H=WPgN=DQ}wAah)dU}bT9ng^{GCp=rn!GeBuY|Q{wQjpl4VKu8K6N8v_o+`^0)RI9R6wQLyFOLur1I)h2dPv)T%S7f z8qufTzw~E)N;HU{_ouLR_`gM;`V8kh9erxE?N91Twm#MOa#x?qwf#vLTc6TAFyBp3 z@JSe3pW11Mb1%$Fhq3jkR}ucRKJ~LcmGkR%_oq_zsS8FL8x6dhHz(%9bRIVXzq0P^ zMti^R23N}ZmwVrE&L&FuSt8kdf7wG#GtxEfEn%@iu58xey$38<{{ne{CQBA-@ zo;{F#!)FJYrNAN~B!|)VuLYA9y-0?a+;L0PC4~-QugP}Oc;U6=fkt%nfvA7eTW1g^o*F* zw=2eJ+}97!&c)dqKA4F2FL9<)mdBT`#eML)CCp8$p=mVKiFNb^^KFPb01>XL(n6Zw z?C3YRSiDZm9b z;0wuoUm?KCB*4u!KvNO`Mp9bi_Y%O6=8TorgCb}VoA^!Y%WfEHCamB#(`@uu$o2Rh z?3yH7ao^47?r*edzvod3+iyZ=Z~HAnsHgpQG=Z>)pio`FDF65x=e>n(J>`K~w5_2#K!V;p4FqC$M*9P$Y-;!4edVwwm@BTT3g zi-h1smc*YXI&AM`*GsEIc4&p`9qD>?+Z&5i!)McCp&MW8dKb9fO|G}u^)|WQde>WL zdt;HU;={2EC}r?E)xEYiPNhU$eY?H1TBuah%e%!xD(!$S)g2?815 z-eHxDiVgcEok_7_lLc-ZztGwv(O*CnI`T#aWVPi-&2*gXV-&1bu}2XYrxxu4`6b4* zoD~Nk?CEa!hg&~qPUlmcuPGw&TccXfse?n*xPo(*lKT>o&sTIICpa3VZOzO0tY~y$T;^hi6+?ssP;s zIFf*)q>zU#hMQw+iCf>=RD4ciQfRD43#fz7tZH<^YE;=in3-c2fNlutPyh)w?9A3D zm4YQD11Xnny`=&u2@s&wd;WBM485vY91F zVysJ%X4cRYX@*1S$lUI?|EpwJSCH71VX+8BF)HurmXu~otr;WQm1bMFq)W3)n*KkQ zW)B?lBcxf$@OGuy=Gu0 zJiACh_a@H<*##&Ol`78;Q*o|5J3s~4@=OGu$g=HMX+CEjCT47tf~{ses98O$-WNQ$ zde%B$Ft>VElP|b`^{f{#Pb)>7jG>&T-G5fvJgw{C6v@_Ro`yttlMF+}|0*%p&QuMv z2brfWI-A{er)Sc^;mYdx7A0GyXP#EG_Wxta7K2`0YJ6o+)$o2^iLtDmiJF>ry=P7K zrw<2(B-(~I6w%0N81S2eeaU!Q&Dj_l$%tCbcxahqOf7N`$KD&DFUSm#UFM)OInXw$ z`JJ(a(>q+ygFw92p5Ar6GEE>JdwQxsobWH3-aY%{r+1%Qmw_BVP#_-X3dAy;W+(A5 z#iL3s6pX9_d6R_tct{&Uy^enD66(V%(g@`{?LV4OMVo#wp}0a}&x89mB?(0ZRv0XD zKPJ&hLNyF-L#RIw^%CltNoj<7eZYS-p>kjU!Gt>A<*08PlZ4{pkLrIk(VQgI!lE{W zil8^T9CiD|G(!FP)cwLStjtBYvvn3EP&>1WC9l}Ci`3PUFYd~OHkMom zFeB8W^&t^1?@T)=2I4}K6-zY|lQ;;gEy5&fUBU9p3_LoSsZ3cl(v3B+bk$KW+7QCa zuVU|6H=fg5*JulR^W5ADfbw@1AZGNyQpSFIxS?1NzgrKhF)$q3l-NIMHSs{b_t6guE>#elCvB(nmz~I={Sh*BlE|a)mH1>x$uF^5m_WDpA+q=sRZE?Mp z>)mR5W04$5#pT5@2+L)z(a>Yo-&cRr>W^O1!9zd`{VRojBay)RMYGUPmY4dk2jy_9 zc@Hk(0k>MdLdy(ekp;H5F;Wd*=Si_h1a7D*7MTMVkGjG{;xdU7wDJLVj=-&01)lLwDzK!_2liDSZe$SLa@|0CDT~c9W;qW zHX#6$PG>~}J@aGh52vN8=FG_I_Hw2VtBhITL0ds$KelcFw5ydHmymZoTKPjKq>hBL z#>f)?{cDW5U?7l#PI8U$9o$}qsFx_bE#WX`>KdbJL`LFu1N>(r<~yKu-ioQq&geizCpJgd3PP|a*EDnx_+v-Qo*W9;z{t~>s%%wtmAO@f1h>{Z3T z5!PI}l}u!hf)@GUcPhNj4$rm>6|mR?xP*Y$Ng-0I>1@q{#x)}AmwqzGp+(E?EntvRRr9CaFCC}Rd<(% z_le(q%nJD3B}tR`)iaCq_2H?i*aeKU@vDX3`jrYFXNPB70TrNo07nwAzZA04V)$Ox zhr2Q<@aZU^4nFDg8S7U{eIcr+@JmFSS* z)-ITZf)<3JV>6Ogb2B-LMuBqTbKp(POkAI+N=#1#6H^nFi7APz_n!1^j8}Hj4e-X- z;~${o>oE4weMY%^DfkA689Q|)ym4MKm9k3f&{xx%{m9gZoRgd_OOhvORb7cF&bn0h1ZXw4 zOM;ag0OPZm;zk7!e+0}E|Io&2y21*tOyB|Rf6^4k0ZZ2LNVrZN_tq49E^famwyAKp zDPC0pPE*JfpCnl+;eu64D;xvt<-L+r`rkru;5HAggIoMNRby1{pYvI{ok6K5gS}O* z4`JKkvra19t=z7Q1h7rzwo15Ql~TELfUt9ZA+>&gW(w5r5xB|v9SZOS-uG*azhd{t z0m`7o&lh&{C{%+k=bdzI*R$F?T_$&p`5R}@B$dI4H$c1h}KVw%;vDpuvrV6 z?&slec;`UTX03)6-viOv`SPNyc|oCd$-3{czdE59_lmWeXAoN+ojnNV@O0>g9Ro${ zw0VDG67wu#o^M?XOad|36JcO%1l1(Ca{I{1WdY6G2U=eUG` z?O~*E5KP|{GbOBt>P(g>H-}XK=L+DA7hs2vgj=PXW;I~&SrssDp;tG<3nXM79enZl zMnD-)iQfZ%|N2C49`AMv?=FR-u7j**mTnF!Ms~$%g@GR90E52^CR^vN{T_1@Z_eqZ zdN32L1i|Pk9w{-yR8nENfR1iHv4l9iVqL#36V2x}a@uO0G!n-@Q{KnBfN$U848zQP zrC-Q%qxUfjPBQn#ubaUVT4@SCtjkEgvF@O<~;vgpKm*i_F|iwCpwt;e=?@R?Pe zliz2+&MrjGIP|V?Rp*03o&9DAt4%v$ttLlltEG!^x?m~k;1AF0?hBT}+(CU~X+5-_ z(q;zhbrY_=cIxGW2UqGwCQg%FSvB$M#?lu-P^d23tUqqd^zA6Emm?K;-TNvu9nBM% zrFnj{{IH^?&=}er{{VxClOZxcOs^X}`06XCOdLNImL)stb(5~VIyiCa;K3-OvGirI zN9huMNa<2-?svezE~ywL#W~CK%#WCN6d**}lYfC;$J|%~?Mv%**IYT}QkH@IaTq0c z{M5$Mjmc7`9jBYHg>LA09;>__1~r;=Vs^SVG$f8z zl(8u!(FBz30#%C2)gR;1!Dg4iDVr{&(ZidQCcZ-?#>V?T`U zesgpI*r~ASIW5Aoi2fm?PtYP1zTt22+V&%03M{6<+K4_~^I1E4l5h?O9Ro7jHQ0kS zq4=)_Sa|m{d^@c;N?P%;a=R6s@DU6Era6GJ+X97NEV@qZ5Gt zCWWR<7(CeNnG>$PrgHq$iI=kH59>CSTrz#4m;bc6T(Yv;;0&xv#j)>$32Zg0X1BVA z>KM;it=PA9+I`yKA3;!uLXpjAw#2XPvYN42WOIjB^AzV;?B_S(T%HIxA!_iX_#Y8t zr?}5e5$qw*V-$39KBdSOS&uaFeyoP4ZPl~sry&L2nQX>k$SsSp$xeW$r%k(b;&q|% zSBs2#S`qMSh&DY(f7&HrPGfOik^tJ=GhMP}1F`sGe77yH5r+ot@?O5*DR1Ia_A=#d$!=Q{;1QU%L&j|HV&CD^f{87k`Ro7k?4W(;$3Y(X7qw;AVLivwRcZ ztOc?<&XM>SO|Fhz5`6FivS$DA5(q^UI+>C7X_<1(0w(T=Tw*=m;CNvepJTO@=LNmX`7ZG*#By>e`tIP`-j&6&Al*lV!Ahf#Xw){ z$p-!NeNKa38%#2grrQiO<=Qq4+E|R+Vz%U*_N%=VD(jX!?l>}kk>E6 z#0MQ=0_Fmf!0Z#QYAik^Ng!=*4$8Hw@*rM_jt|CnYJJ+`aFL6{`KdU}n0)0Az#%v> z6$k2RHV(as!*YDP=lk21{~C_f*)&+4EPqOn6qs-o%I~Q^J$}kGisUI?Y=U<0_fVv< zxOb8k(@y^}%u+pTxG!{a{4Xx*m#?>HkzGY>9t9+2{ttOM9K%cmkb&svVl{eR``@^Y z741?5$1<^Do#a^mk3*u=7aAPjnL;m{lCL(|=xBn@U8Rmb0(?q=54+@czm{7%NRQ5{ zwjRO2BcEqb+gOM%h3KYQB09Pn$kH1yHkHBVBYf5eIKrGn`0UMQz2PTj*enflv(O zdd_}%=&*+f{R6mtg9y2xpkiA`4pIW38q$|KChM`d%$&7^Ru(Qx)4#RlImUC%AH(cI z#*T&z-K@;jwUX`H@>g`N6jN*xFN`y1LW*#`rMEt>7p=uJwTQqp<-uD)soci=NwH=iwwY{90Bu|#nAHt=Da0v^r8l>CJV<1pyol*k$g{MK470o)|FYnEj2apYyJG-3zANpxNC-X0_P10)g0^KM_&uy1VcCR~^ z*nNbfVXB_c&>TurF@}QNeroBLp?a$bvws=JW#e90Gcpm&y$(l4rpO0L0oJ)*J{0Fg z=E(=?jF{WxgFLUcPJOIYXJL??)`AWEJVZ)z`x}D-6k#;KJ;jhV@we0 zSG~U@b1Ed8&E_7-3?qWJ;oVPR2(xZira__8bGAk zlHeKy6*q|E!fo3HL<5MD-}|1r_jV_sGvD|9pXbj*`rfL0>eQ*KQ&p!8sh-aV{|R68c@D;f)+u}O#SnmcZ-ttQR$Bdp)nwd&y-fzNXQQq- z_(h&QoE#I4zsi_6cQbWjDf^P@`t|lef<1~RvZ-2dPMSD1S1EtITlGrcoj5KR zLePe4@3!&NdZu|^Nr!PsjAi(sKN}?Ti`K55(c2p%LZ6|GFgtBNj#soEu)aXe$EUzB zN9F!^1dq;reJ@aIjb|gN1zpd-J3=RyK!J% z3DMp#I`;?olz{qmbE2IM5!{vd60c0$8&EhtfZ4uYi~JRuiTD=$IGENaUb0`c$O52= zo5^gnNRTnNrN)e9%+0AWe_+gr)R;>dQZm` zz!EYo-n>cVD~$XOKPM`^F{U^*rY~dqr^cMln6px2Ixq&;Mka~G<>+bg%+#3gnfw0K+;OL0TKqE= z;}ZD-<&8LgQY+yhM($`5xsZ|TRV3>n*wvkeS|C;pe7OXgjXZ?co-A;sr@-!b9Y%kb zZHAGU;fff+Rzw8Bkv7iY6npp#&Z-xo0#nEW^s4%ZJ*81-bA_g_5Qq;)){^T5%$4H# ziwW#LfcNpb0$<9l6H@4TH~}}So9*lZcRS;9eLr_L3q%kpGudYnsb<#jZ5&a}brf%` z8u_3|3QtlW^7-L8`5-fHaA=$|zhuU#4f5hycqAT?7#nFGW1f^48(TNVtdtl*qlHU> z1sTiaeI@Z@+}9#w5gX5Us+KW-U<}vsNbI)r>#U;mCXuTc`3-(jAuAa9fr?a(x`YVt zS7}wI-x20T8^#fje}Xv`KyM7vR3npn)UL9(Xh-IfGF2u`jzO=;4vv`3V zP-ne=JCszXBIYG0X7e40!Lqc|bxzC+Gn;eUF8?|Yw*WV(snzVm_S@7%3Q=;vDETIe z-Io_RQ|siLb0N8ywwQJIJjSWL7F0e+t;-zSvU zply!ek5VH=#BKP)64}+?IrZ-u;lYmk+;4JN>Bbx4j0Ed0V|Icbs%ogBRbRci7 z*~|WB-G)kHrM;7c$6ZQ<&m=tc7OO~!_3}Cfg>;u}DSUl|6sYwMhg7R8iyvJlsfH1~ z+2<@)8+@rax$f&NAS}G~G(fPK4&yyme2S0^rc7MIpJDj<@3Q_Uv$L~)k9nAV{*~4^ z>**<3_p%FrMK5xaV?WZAANqkTT-gxA9d}qtR{D$&e8!Jp3#?*geGRtwu%Uy)7AwdP z(T7$h*@BhA`>9@L&eh%uHet1Q1!BP#J>CX=zNi-*<;6-h!sK9pK`@e6>0mi01<8y^ zLFfuWY+ob;n4AL(5rRE9U)iq*fyI91oW@s}4&%FGk3CkMswn2hbs?I&Gmi4{{H|wF zOJ8(Gx>~FIH1CXTEYk6Wcb@1v!du^9q=B_3EXSZXOyaTG=52iSENbD4PEX>PZsWMx z#j!%+h!Mx|qi`(3SJ6hUVkxcuYnh>2Jx=J%Xl4{~I(RIB$_iKNOLEqG3EoXvJzMMhm(%(JisOpVfEcN9D`aiQP%T)f4EKHp0UI-+XvNZ zHCRmm7HaGxR{0F{o`x+pf};LU6W_E?$r(MQ+*Ee6yWR{yyI|&8W(Mx8T!h(vYPzwl zHeSCm9g4N7?02HIw)(p8e)B~k4ssS0mDc-ULZCaHN)@t&0PJj;`M74%+xv^xt^>in-({A0$P&bO!}Wm-uQ|S>9y;6*xC&#+R1CBz zNd>_^^cj1tMTCsbu4JTMy#b$5ijVkZD!zClUtl<`4HTqg2PZ^UN8~75V*m&YQ6B-P z=pn%VgEoL~ZZ+L~B8!EXu9>~x_}TgqZq*ifE1}Xm13FjC`y*nB(_K(d;voCk+6vIb zlv)b}t``0A?1k3DXMt!@T@TIH9c}7WS-R2sHtlE z6;oy%M7dMcX>qAa-s)YFGWtqOFH8@1BdVa!#t>LORdKRBeL9? z=q3sA`c|T&yjG+Kwk2?c35wtD>h%vQv*;#V2CpSo&P)s zpdlE4hG6(v3r_oQho2!BeIE9NUd@y7#|Px>dT)anytG2 z44DI)%43}UFt)!hMzOF|x>HOB#Wb-Mmg1&9QV$(!qb=Z?8LJ*I)f8jfEYj1rHGBp` z!fY+F17FOkS!*~iFr!n?X#pRFT6iZ1`p_oKN9d!*EI+pGgB%+FBl?Y6 ztYl5EZ9^Pd(N1G01rSKCs8dwtv&c>=GXYUXbo$3AY&Pw9aFTJ%_!$AkHgDZkn4%N3wmrliB*w_0n#>DXnMjvs`| zX*Tbg*Yp)Qu zX;}Y0O`z*oRe+WY6;Z+G;hT7>#s2@C1-84`u88y*3-VE00O>vq+6nuz#rF2QazcwF zciG--_fEC(Ai-|?Jqbj2wxEZ1MB@9FE0YLcwBM7kS(0m??4y5D$FqErR%Rb(M~J0jhI!B#lUvv2{sk>|JtyaODe4-oR1Eg_&Zluu=S zh1L&36s#jY#IMg>-wz>LOP`b?pRvE|c}f2DRWBeI|M|@OdP$0R?L%bI%NvZ^P+fD3 zM9oWEVgD9V_w|W@e%8j`Tb=RDXTHMgclGLww-pXMSoAiCBu+Q1WbkAdHV#O~{icG~ zF*HSDffMxuJ3)kvkGeE%8%9d&M|1eJeIHu4VGM^+2!(ZW=%4@0-R}nLhbJj%;Cy!hb~dBy`ibCi z#9BL+XM0zvV1xB4pmq0vg}Tr8;Hk;_#5aOs1?=%9mcO7ba6A;B)3SQMD`;xks` zVQ_mQ4||{rK1=Vumr%zmsM;jdr|a2rmWBdB(DWL(@7frj<*W9xuxRiF*(eMeZDz~; zx^{Lf(MdNp=-c9+2rU$S(FIvZ0QQlGF#^Xop5yD~M#g78)5|5J z7A7RNtFwI3D^SJzU=|OIs2OeEF1$Fk6W@jaDXj&i?ktMd#J!0)PiQ?qr3JGvSaCeU#M5ByL|5mtPWdviW-2ohs|*h7&`v7> zM^5Jr>1O6F-@4kS5_TM=eH_hKGxN^x+>bMpA7x2mW_tJ$TbaOB=0S^SAs$*~#;<5J zPVm-vFmZ8o{8Yb@5J|uk9lFl|$0+j#yyD{?PFx#MHMnW>AX^as zaHTw*#)2@=DqdObWF(NuD3*0X8qiXPFgwX;Cd6~3{TyaLbv`}S-VzRz9J?_If`er- zi~+>)M4*|0j^3GC{OV~{7=aXrZP=(=FmI#`7`oOp^q*F&_ zV)jQxT(*M4E~J8Ju+}O@A_lDM)l02)6<>^Xe0(QtZEg&rn-AWhr-bkLw2k z+L|YcS-2^gw@+`6BBPMlDIcFZCikY`%~0;=>#N80%qL8Qz&CnohRoX=+>U9x?SG5-W_O5B>b8M!28B}U`nH1zQkFy42w z`ZY@5sC{A7c)ld)a{xI!`jj;wOx1ZMnjqxV!$3_| zuOt|rEA1!Qli>M61Z*Z_|j9skmu>ECr-Y($JA+4pfn&`=bqZ*nn@E& z$+~3gi8oK4GHv`ggt(uDKxtqiSeI-)_SP}j?iy#a^=VV5jk$T!7<305Tj+~sT04vb zGkT|vCFAB!8EMeF1zJ{x*sas+y|s#U>#SCwux$2LOwM^2{hAgc7bUTNKqcFSczTLc zh#SWQrc9bR7P}xiOyF||Od1~;bL))=p^u$5aq`$(gX7Q}K@3dbg$nF`1=>Qh;^ur8 z+wPheY^s}7+Pq|b<}@e2@#A_-A2V$t?aJ+H3Qi9GU#bb6|E62VpISBO!lt!#Z^z%P zt&ek9Td$|FChZv#+y&JON6+@s|0)5J?7y=s9OhEv>jV56+C0);!J&JxMuI0M`d~e1 z2ihj`v2a#_z{$W~XN^TNVPut6uyZ0$`esU8!0G?LoBxS|sKKi5#2(vpKWQhLn|;O1 zY_^Ak9-F;Z+9)!N^J2A_2m%PlPvwpTJ>4+*03ad_uX$%*dmwXh<*44F~rFo~lmIv$Sfh_Ly^$x|6pqO-I}o)4SADFeE$p7mqmu zxOQ88Hd8qg7}NXR(CnqnwR<)ql8Vsid5jPGU{*dnEpQo@3l*5kN0RdXLU}2q@P2wo zqOyFU%^48Gw8#ViB)aQS@lyt7t*|m+G(&qw7o?ClOjQZWAf!Rctrr~B!Y`r%l#FGH ztthAON4{!UIPxat7lnPiVoIBtvPRZ*Vfn!K6`rb;YcuH_4s#YK4~3d3kd z_>J)utX11>P=odOd~TXG?isd7ww6l^9|0^}tWz$8%{ccoT|IV#H5eJ7f5!lmwmu&}R#ivDMBAPt6B?wYC=+s2 z^qE&?sPw}Vleg9Cv86$p~h^_ii3+9MJiH34W@ZA>K2g z_Yalh5jdWumBQhIB7UHm%Gxrim*6tXL|#QO^U=-b=HEq5iHb`Gdw*mXj&oq;HR=Yc z3FU+JZ8jJ}nc3@P1!ucr$sl2jC>0C8v1_qN_5f_t^ysR;5K{97%hb-<5?Mnj)rJ*y zbHRR|lLd^|(Qv1KJ1 zQRkG)mkmER*I#?0@49&Ll-sxK+H*hX1^c)-w}zZ2OP31kA5Va}M=f(US7=IAW*w56 zR8s*sl)i0PAnP-U&-{9~+m(W9fwL2NrYvxPWTo{IfSq~_^CAl{Fk9bxP(DbVYGP0k ze-2-*j;K}a){RQXv@WJgbo#K00VD1lP0Xs&+I)?4e za-QVH+DBv7;zRsP{;c7TSpBhwGBKJy*u^F{*t1^jdeVcsb0}t|^`+((Cs1c^NC}e! z-gOGLQ9z_%!FGx3g(k&1!vNBYWq(*egq~ng;(8d1Nr@W?NQ0$-7&n~;2o6eIp6HRt zO0-CvnK(V63M)7`c%Z#}z?uTyK5>$ubfn)qGl~rOz~GoVcv#|0yT4HW@RQhD6%h_u?)&{8-*6R7EJ*G zG$(~+ljCL6`k1NY^B818i0Lb<>B6GyQYHH}#MBG}nXjCTWSUEbpNd!b3f{(Qs{%J+ zfviUMBDfN$iTHOHDTnxX8C+qprVinB1d=Y8f%r8Vj`eAezOIEPB2;9SWZ_&`r5rvJ zyVK|l=+cg8VN;so`{IJ{l}gR>9l);o2hh`CEX+74y25!vA~mX7csk)DM*_Vuj8i{q zQJ;EH=~Iyq`qYEL5k&3qg}Zha+bhQL6TXq&vma9{T=DTN8{L7l~XMh1G`c#0P> zD2d}ft~8)Vhc6N;h_6IGhXNX#xh)mLZ01CBSC7hz&~o(#R6UpvH*;n9`v+HOkz#DC z+00&}n7xUx_{-mEnO34BlVO~nd<9#y@Kaz`yZ^$OOwvisjTOxxfMmA>0|LT}Pu#_& zt~~q_TEgBaP`fpBuTyYDvGYN-Szt31HwUzE2njgPV}oE8HwZ3L&V`u{0+-y9@&2f^J+*WZgR*@@iEmh>4Pq?A8Ncq9IXPER^3OLR>BKGcN2Wdnr# zy;t!!c9)LH->}~VZ%lwD7h$t8Y(gWw1qXCzLG39&_->(7`q{ ziagq*TS_nSnA5Y|h5o24N#02!vBH#+=n@&|XlL=^2oUDhhukmti59sET;i0i#x5J0 zH7liA$zM(76M>lApdSu`=F{!g2CBctfSrNAX zpt9FQ@vViq$L=Y6Z3h;Y5GZ5#74Re0D(q6z_~%&yn6F8Pb54I7QLbLvzWymS<}~6A zuE4yv60&5aoNLD%2-2`)Ljl#-{}rMw?V}shbA@BMe#r5K7Vv8?#`v%Z?yc4vScPHx zepI<8R}dx!!61)vf;7}u*4_tIw?u-#JM6Z{tHns8@!ZAm0+uz!=HsmEV&x(Zt8GZl zs3?q!{V-XUqrRyRY*OQfUE{s)r%Sg@a4=|imw{03G%d5HS}f;Zb^SYxAFML`@e^lW0oK(Uf5Ml-j0xNE`y%ZTf2vFI+<^4JK4GccVcP z0~%9wGAL3!@N0mkWC8f+;QG?-k8bL#klOA_iI#9WD18bYQ(km4b9-%aS*)R>>M0%7 zx~Q3EpOsycPD#N&R?LMTtH<6dS&VP2cx;ud`jcq=E3nI#i@m%_W4Pr3t$%57>eMOI zWS0+{BNI#U@z&dN@eP|JVjGr!7DLz^DH(t3RCt=`r7s>wo1{ z&Z%EC@B!<>hIXigOwT(gK`7-Y?TWWqq)y%OAeaZ_$@ZSw!Q7kn+a=kEZ+1yOzSb#; z6a!g8}Pg}Rkx zNG;U%x1>;hJXok(K`D$>age1ef4bm@+5jYH4rg>apLtgW9=dXY;VXDc z3qOF-*oYJXff0j|6il%>ta3`gE(VnzspB0yCIQElGGpk`0qJH@dX{LVc{DY2u$303 zwnfy_SD?pRT|3Z!qS%_#%Z(~m&4wrY%T3YFz2p@1)w?0 z_U{SN=K9mqFRjLWkV)r^+4OQwN&RJ_dhWA6o8%rpoNcvAeS2d_&6G^&8|d+qUHOwYlZsX z<(pf@6TkH#{$f5Hoq=}qR0C!F&v=D7jw6N@L1Ni{gn45hgPOQt4zWA(SfzZ@!bQMC zj>2U6Ugs8Ra(X}u7a+E5e>#+6Gz~%zh66H0x$E2YG#p}dcnG3hCMmtUSz1xS=r-Dt zSa_2bF3u#Ei90i_10dKCHaZI~ig&|v4g%m32&=Y5lzw2pZfw()!45PyHC)$)Z(|yq z4&-`y65k`c12@X@Aay-882X&LV3(qT3E9Cj89YryokGQy8jH@MlG_B&51mYV;=C2f-GzV+v4xxTknr?>_UrFgV}n2 zoKkP$cM#)N&>zd)3d-FCD5n}Dyu>2>u@-rY%!+M$^n)N;UY&x0Eq3o#c5lxdrK96> zm&|Wm2;B$Ag08o4ENDCM-*AW|<3Jz4SdVu_55n;R=oxs+1dkYW_!<32ol@2!Pte`` zzxc^GSrN9UxO`wnHPaS*3<6*3rY$&X1gTs{N;wE$rS06W^+<~Y5f>38GDEcmN z^>LkX>Y=#%SB*0dhLq}}%OT8@Mpcn9A=}SWU+h0jEB0Ui(d-dtXrO^Jb}9uNID6)W zRC8>nilQu#R8e57gUenNe4nuLa$#lc0k(@oWRQL+&eOh5X#x9a%tr-uj&N;LB-?@>MBczm{J#q)qm^@cM6XJvK4toZaHbumyKh63SC z*vT|*q=+2)!cAAGCEaMD8*+F_k4gkIjQe!xvcbjhG&?AZZG;BGI03$ef>8}HDGEkg zOVUek5YCbXHpk_sW$=aK24yl=ad5VF{tff~hA%RTo8O#EC4S8*ocBRPmDS_gEchMg zyhfR%(cCue0Q&G&G)L;hF^RsgAsQHRVLd9U>&%|$DZ-n zx|}@1%-u|JF=b%_DJF?ei<}3B7N3)dmt$Rh;|U~)f6gCv2PeK;d^@Awzz>DqAq#(k zeW)aXM8Qaou+RUP9AU%H5I&Rm@5P(s3p=^L0wk4ye-VlZ5~YFYmscmqYNV32ugk)=qV zq%zR8@%-4$s@eaa>;EypaFi(9CyNJLi2EyIMTonXPBc(N6xc-Nt+WF21tp%J=qg`8 zNO%TVD$&*rmXO1Eylw~yaQQ-u+>8(LY4`zXYW$Uq|I^X&eHnk*(ed3FfA-PwEg8>~ zG)?e-&l&q?{4|OGfbsu6I(|LlU&l{U-r)M?D(oa2w*Cl}5{wMM*bU`nU>w`wJ@~#K zWe72iYzKEdws(37|Kr4TS~z3}$HU-YwBBDY30%jXfsteX@GPLPg^a)@E{Zo6G)8fq zgW^;d1@@naLbPwA;!gpQdWEg$z&9px)aY~DB{F!ti_n_;+tLb#?R*UV+)SVGt1lX< zfqaZntftsp#aGz^=}J+@*h}#%Ss$j}HFQXu-70jbU7$S{ve+1g+y|9-9Ag2%_hT2S z#w_d_I@s=x(-Li9Y6XRngy1h4cLHHlhy}l<^UW~exe{v|XzP#80v=eU;oIB3(4}d? zQR{Q@(K-%PR}bon0$_fF1+_f+3t~rR`;3-8Ga4i5vLP5a4#qbOVrk$r*Qqj9S*>8) zvS-5hPr_FyTPwS)0)B1l?o>B0Qj>c;J ze=5)Q;bWGk939RnPwW3sp5u-#&vE~o@# zEj~*4@Oz9%dpr;&{#DIlGnjE1g5TFj(0T;=yyXO^FnAiKX@%o9YFfs@>JCBcdKYzs(QV)1)cc9Yd`NEzwQqHV5B>uzX#N_u zf{=l&tC5w*5EzB?9cGbR>trFg{(!Zm`uYMmO=@-(r$97el9F z1o!Q5@L$H@zY+XRgv*;E9Lglmxfo_LSm6ejGkEv!AspTm;d4GDne5iU!^EJi`W=#v zPsQ-LFom@Ish1<=mUo@9UBTdVw=GQu@55Ze#+&oBFaXt7(SgrkN{ipsLDUDy{(#M{ zuJB14I+Ozo6@0`YZc|VH5Qn&92MzBI*)zp9xor_zgcLL#}CIbl@Z@@kirgoJ7s|F&y z$H}L`njon7l zA+IA;w9{e&M2mO$qnV7cu76cEMaMrlUGzpqFMmu$|2hm(jCV&v4K99Gct$BaMGDU| zz%!BwI=-e7JoBV9sr8t8BID_>w6nf^0E)BZ>75pF%AqUM(d?@RWT(keGiL2Yk=fq= zA2n@0Djt9sJ%Jc%{>< z3;FeJ%seQbbq1mvH|u+@c3vK(K5#U z;ZY~$YYhHPu`IIL%;0u=g6QuedX>>{{u7A0xQMneF3Uv}WYFg#+R5M|8_^HN4n?($ z4iVAY?Hm$5WZZgHy&&OS2Gd+b-!SO05k2W5`hwB7KMq6@7t!2{5cfEikgD{bUx?r< zE`bm7tF=Pa(P$UZJ&fLfHLptaG=s;(Dm>o9#rsd@b%PpsL7+*zH@bM&@oTw_H_OHQ zGNZRbJdS?>8C@Y?OytX-b%N^{{0a+c^)I^CLXCbNh#qtiT}04j zF9@hVdir7nIgXyKH~=)>M}Rk8RJckVT$!&Unk%ey%udXuV7Zz_q61sERnz+ntoiW; z*npSd)_aP}Bxd|dtMkh$=_wAC)bDoO8?r`)Va7v8uxuJ zIaw1QV|fl^Y`h;tsmyxA_|K|X!rrzL3-d`>RA40@v(_Pv&%Azv>U2LH7|rF;K! z2VJuQMDN+Cq93-=VF3Q(9w(uX5S=zV!M`y$_&F!|0fP%3RO#oqXg_CkuPwhLj)agw zBa!YGCMkyIRFQuv1|;hWMHp)1eg-dfgZmlmDXE56ho^UCG>A#2nN9a@=HOG}q(#~y;yBWN)`gdyJg(L<{XeC&tsfOIh zl;hRP0u}uogPk`yU(dm+#Oe#t6u?%ue=2qs`O=ROk5X#<9ITL_Ft16pq(0MCacJQS z_QUv;`j7UrzX=`64t^e=gcz0U-#LKY=vKfd43@hC?q)7)wn1;lT(=H!Izug^ZwDLw z&XVMsEY;CA-QA?Z25>}*x&;$l?bON%#r}Y(8@B#V{Y`6%a1E2Zi6p8-8yH;odl-5( z#bA=HE_b``5@PrmO&b5et*2KR_liqq8?LKHs@`p_g#SR5cOIiZgE}|980#|?H;*ZC z(9;f%B*-at%IR*(sf=ELK`s7AH>J*$g>K513G#)Sk*oo3%C{MPGN9sga-;HW$CRzy zl*bhz_>`TpnVa%dMu*-+%3Up-lsmZGeaEfLdk8YsPFdr1%J~eV@5kaN{+OHc0j6By zrfkL?l8fw=e|1xy$mr+ZMoKtLv8jEOajhY8fp}}I3;HCZcf8|3J;q?CZBFn(2CsIP zV|Oz+#0@TBaN%|bcn*Ufx{JW+48E>{)=jEDFrz+}NtXS}%D&4<$L%0lZ>nlt$l$y0 zIbUlS>;UK1>T9dP2oB#VL2Fr&T~{aHfN0K&i`0x`-Sm)jUhw+OOi=ovN^pyv0Fa|? z$bJfvB+dS-Kw<8D>Kx9UN32;`d8mA&M03YS3QeAqZ=Yuwz3O8X-PVad`JXm9Z>#CMS!&~z>_w>wdf&=0?FzD2jJvq1Ynod&jnaX46PiAIP-ZM z!vR$)RK+U#4?RYl9k3k?wBzB(wgwTc!K6o7p3bHtSUM1xa)>6*?q*nGmZ#69`Nq zA0f#6o^WFN945d))fug92eZA=Uu9jQ+RCc;I0YQ4Bf%^GR(bArqf6P*E1XKsyarGd zQEyO83rc1XV2%smu>sb7ZqwFh76E!XV{7JRHo!6$;7$UxbpTE-6o6gU8(%mWLIilz zDSPHv8^cpBz#;-1b{aP`WCIv3Ksf;xxfmX`0ZJ5rReQhUmKya$sWt+_y3Ov&+n~T# zeEu?{kB5Z8An%Gf`N?L`_UF18tsuZYOz;Z6lC99p{rV8UZg;iK^W0lH!pH>Dq&*F&1ow~ru!9Rp*XA&>%^}F*lOk$=Ss5e1@^#^ zxU^9z2kcSMJKX3J&M8ZrO6*h3;MI@;R8a>K*ARCs9L=vKE^v&&R;B~|A%mB@U-vPX zaLe*5iNC{T<%{|CTUSC!XGS-uuU6-!s$SZuCyJWGqE5jOE!#gS`YB8;)_npEs5P)h zw9YcP<05Me`0Fxilo3hrr^IQHpP-4(_80UDbio;(YzgB6JWsY>kmZm5B|Es6J9GWL zF#EXx&hD{|m3mA7dn;W21V<+REUzom12-pdr=yC!EHT`P{X^nf=XG%63J0Kj;sWQj za{~5_NCph2CwkbiIDn2L@74qFE2TuBb)tg}6okXq-PZUWYHJkBsOf-V)E_14s_z>b zmf`P9{Po=1&@cmk@8B_U#gb2goSU)7u~lcNs55DVlxP`M)4?e;3V!}LO04| z5L?cn;N1&M)fESugK-$Qz+4(93GYB6pBc_u+6qr2oL7OTZl2&bC&COZ5g1(@eMx-_ zZTSMa))|`=Y8xHyOx;g)_m_3^vQD}&|9RHGc^Q(;e@0$$i29E()42CB zh72)l*NxZx#s=#%o)r@8S@6AM+y5o;+5To=;4>0;3a9#-v3HBbzDxM)>Z^E4Bbs^O zvCgQp7GnROV$U&idkVjpcfvyg#tt?ZU|PX#%Bc9&fZ)rfa=~|v=W6GEgc`tki~~i+ z>}O!PyAsF7Q8lw`y~eM_aIT7dWxY|1Ymj_V=dH{!(w-?^tpae8W7v5A(o zO%JhvLpAjiGe@jKaCo#nP^8W`4M9U&v^SiS9Xu^QzDr|!L!QSk*#-?|X!oyePz~|GtDF&Rbl^2u1~bc?|7dJ?w2#4=J(PbzE&GbxKyT+jV7{Dn zZRZ|!eHPUckKrfP%d!zCYZ{s$AgYM9uqM}g9Ot*XVuE(FqH(bx8k zJlOL8H}3y@1qWbacK~~;WgNz@8OZa1r8tEu=K&#t1Ws?%NEl#s(;+yJgLaa0u78ws zu1R6S7l}xt>KUG!_G8`0ZnW*uupr*TFe(&G3wG!n%#n-~XVqp)^^kCJ#gBG%`knyl^bU<+ep z*Ctj4eq%H!g}J|YcU0V=g$p@A8m+OL92bA4aA8bIJ`cmS4<~fAS6W8(YVDP+p+m=M z3-$p!#))p7m}Vm`n}Ne*nCTU-Y^c-Czd*|fraut_mB+je^ZQ^JFYZMSSfKh~mszlj z-I*g6&s@TqI2|0pi9ic~g%!8coj<}m(gjA?_NPO#=qIyF!HwC${P-=v)o4FXSN$0% zalX<|`{4%!m-Ok4@hAd~;Z4CO_QU?}8~wB&hI3O~MY=QC3VCQ@9EJlelK$OzF+ORp z#0EZzg8NZUEi&skkmr|DhosA~!hWD&E-;*Qd@` zP3XH7C>z&rDt*!(mkUapzJUldhCfDoQX9=uG>ZI543J};7ZLI*Rnc{~;E!BsQB z>BvjEc^lXe#_t#4TcO$YX+KVy`yz+zDaQCnFWBv}Ar7{~T?W|@!UNclf|O&>z8~*M z7r27tCgmO4pOdzh1vg{|a}qP*nLwFE^ZdHMpjL~l5hP;2{%)K@-LcZ!{P()Q;9V`U zkSTyO6FBL9U(&vx2yi|sHeUC2|0spX$aNS15+iY(IaX|*!3#9BV&g|&=#sQxVdA=S zjOaWB*|lI(X-CQ;Fc?PBf>xq0stEj5u(MPvhK~xEh`>&rpWb5HKzCby@HN0g7LFip z(dIo5L%76rAQ0qV`HhEWB5O6m{N;`Rc7(zCA{kxaWdg%gl{ITLMzw~*Y_=jt4!}Uh`V4Pg)0l^q78B z{HfgBK`p3RDIW!=KG_!xaMu|#24|KyWelq z1J{VR!2Q{5_&b{9L$)MHi$G_Gu?8l){(@XB{3b)8&Do9k$!E5K|2BI;H6}aweSCRS z{2*R12Om$gM|Qjc?NhhEsOEfRD|gmWT0?I-YbZlI9;(8^jRHlWrO#+bkG~KTrA42- zfhIwi38N#Hvi4p2!!&4?>PjuIyFLV~>g+JrqP>xBsZK|hi+{nf-cWTLe}AzX)*`oH zyDdHvV?eR7!Pgy)pBjrixEf%tD3 zg!9JyW-c#&p#iYdv(8RnEk)rD4e}fPE&d!nVtw!%{Y{H-d=Y;>5aspmAEwL@kzFj; z8z2+Nkt@5O7TE;&#DpY4kVOT;CF=Bq#`X1Y(F5DHjYBdr zIMHq3C%61>8~DXPse)1}qCA9#=8>%~@joF$d(sHpClaBK7)VLkt|0QbG}P}(NjQ@N z9#B$J7Tzg{6oS7U`J*M}!JNd5M)IG?L(szk%9h{WLZA`<+36kmPsWE8Od<2{joE?I z?X>U5WnFnx=cFxr;0cxB6q^BzHdU*tGqc+tsIqdpHQ)`JxeD zU5U?$OB zq^XVQ8m_!-@s&2ISZcPTRk#o0(VKtxiST>l?UGs7ZLGzlw_Pz(%O( z>sBGxN>0hw_kJA#W^VWBOevxUclNW4GJLae@@DjIlx)C{7+yfG7+CEj%POlC_V?_qpW4oXe&*U7UTE0>^i zZ;BSC8{Wl!^I7IuXx_10&V)*nZ~#6WC#}K~wg>tH#z$80ek8>qgHbC}`3MK1Qx{6&0`v=J1f#qrDh{dbXfx!gI{o>D9Ghw;A z*mkE1)zH^g3uISpeCONnmCOwO=2LCYs;xFq^|Z;60!{nyS96fR(kN_GU6_ppQd)K4 zaQs3@EcDw?NV*apU_Z~dpXb`oJp0+zes<)ust`_8s|%;{y}IyPJ|z}xf zkD<|`K0pi`Re@S;-3}-+4}xZJCHAsW1JPMIL!*H{Io53|)Qh2B)-4DPHH-S_x>2a> z{YR|~oWx|I>S2Y5ooWS)R3^ls?b0l=;p|t14FOqX{A|s+mu&b8&-$@{_?wTm*>E1K9g>B&(kx!+GNbKq zvjZ3rY-4j`4(cGy7}^z_(+>rxF6_k!JoD{mE}#E_WB(_dxCcfnFk}77`mE>gFypK& zUK3#QP-P2M6Y8kE@ew=(h#9MlukZs!p`9d7sFs*!)2kxqGis3>MO%>`xE?dcFvQ^6 znr73k*P~G%0*G&k_>p)mE4VS})wS0=>5#o<_Sem}S1#(1R$nxCU`C*a*hb5-O8AE0 zz-`@rBt0#W=kNo4t7& z;gx?>Qe&-ol_^s?;zFwn+8z@#TAf~CS|Ox59BZ))GeUo(BgY)8l?wG@sF!tk4Xx>l z@}$3sD<`hW06mN=1NJwc8OURQ8oZ@< ztHTpCKi>uGID9;aAgGi_O79Hcg!AZFAJ;hhd(Z$vo32IfKL{!0T$!=vR=Xkt^)HC4 zfr13W7Q6(|kP7{7XfcSHySWCLq#XRj$+d@DVoyBUXT3by{)ERGdaJbBunBml@1BI( z<-?9(N4v>`=Qsx>`zCHiZWY#>Xd?S#;B(tCYA<03Xmpj(@T7n!E;%2O!X@`0lHP)gj^>62rab{@{=g8>Vg*+70kl0tNd%8#5LCT#2L`GD0rObuc42H zjtWZo*A%Ev6KU&vfiP>-YH6q}C{$!!Kn5qx`Sw5SKP48P(q z=ZM;A=dem4jG>mW*|0g$-DkX6-2IniMQV{3p`wU)1{--^r6}WTwORHd4x_2L4^i0W zzut%V5&IB7QaHO{aC7W#PR1627wu^U@|rZ{2g#z)$uRm(>%=f$_v&OcZtcSUgAe-; zy3xUB+`#RJL(oF8>FwPIVHNH^Sjq_@+dAPm+4MDsYAy$wn;dL<;!G*`DO26KVL_^! zrMc|b)=yt6=AQHlZIBOGzE$idSdTgU%KH{`U<3gDP&adMM*0SwF4fH$+4@=U>l=$os*f7*3GhgLfc6_n+TwQV0pO;=-uuWS4w*hJXvkvMT z4mR^?&&Blh@nUmpnNtyux8tO6=kar~7S z8h9wUxMtCa4;BuuM8QU&V8bih`=hs3cGOqjZ~v2RqBz)9-(bOGJUoY|Zv^}NtvH%j zhOz0+c9;*aPepGP-wG8Ia*7Rj@4|+d&lsE!m&A0qjQix+$c^{ky}h^gj>U&lHhBDn zcA_3g%9lsA4~~9g2=>E0liVvurGO7Liaz@poD^b$D#liJ!7uI@{G;q0HpeJru_KQ2 zo4v5h9k?Fwf%7MnQy*=QzjbQ-{ZYnWD|oTD;7*LcHAHD%L`Rq$e;s%={#wC~3hI$0 z6vy8jw5;{%i`>wy^5WWTGRJFah{Rrdja7>ep6dA&9pF0XQoNSq1?8XPtDgUo#G+8u z^Pfq+K9+o4mVD*>!+*f=Djvk(shS_dE2B2^iGPUV>`sg%!G5JUVZT!DuwSj@YhChn zXY#eyeg%H2frS35`PqC$6tzVBhpWQjuNg~!${dCNd0z2F?tT-;;ui<(!?7Cz}6Bd08hC31bnTgBaf z#Q<&dh8C&ALMVPI=9Ws9!`Ety%qq*ll$=$*&HS%tm7g%HU~J!Q^*Du!p0Su!ipZjM zoK_m~<_F1g$g~1oe&P?9R+7;$rim6pxo{OWi{W3WRHhY7hU8}3ce7%D&MS3lULg;= z^NL)82fr$Xu$QUA^u4!9|MNksZN4VrC3-2mzg}u}exAc+19~ki!pzsm72qC+Ik>9M zw0>C0;Tm(%>h_dV@0`hK(Amw}$uE#^d4C!{l)yfv1Q@s)51#L-AFQVb`{L0nJvfNt zLwy?D=>aa^dKd{gO5Z2XJyz+zIGS4v5tL+stpFQo%~auD>46x+gRBySZA8IW60dOx zb@fd$euzEIq7&;k;Ua2dXRW2Zj5;{dY}y#c6zb7w>1CJP7`%$1L3;Eu+`j(WAXzMd zzCNeU=3;3+7E9-YHr;sJ8o3WEq+Yr?4Yyz%X;!)>aRT16fg-RjflV103)$&!i%E+2 ztwAUVDqc)-NL~~A9Qz!|m)HV50=KU0*=XNW%9R$&*Zj_0>oZs(iceMhYw&Z?e+BR0 zr9Zvj?Y)&%w=5fuSIr@#i_M!$d}nPA+{g*YvyS}Sdut*KY^jti*bRO*X&(ng%s1>P;Y?~ik!LKBQ8g$h9eA^o)z!GZbn~t( zC_p`x8A2tj%xduBfhWD_wb)yRv)X?kTx@Lf7i?4WK&^gYpO`o-NJB#O_Zpc{Ie9or z?FinHHgHMf_Mv_n+sN2oo{=5wh(%37joM${C(}etaG0Z?P7F@kE7j6oX@kG}hyH@C z!JbT?iS(2LMGyW_;>2R(!{Y9+xoAXCWQx>m3^%uhs3^Aeg34#TiC)QU`)YCU>3OoI5QYp-ZeTb0!z) z5OMytNjtmym5t};x!=(HRk5)}$2P99gvv={)vfpiS3|UWXBH(nFdK9^Sm^Jq%1m46 zy$=#Mq-oq~X$G^_K-nfkz>bb!89ER~Tsu3i*K>r&{kDi}YsYn!xcen8+m6eUxCbPz zy&d=CznJzx%tj@=ishWb(a3TkK-z$*iwwDyiYh0%%kUW9Ht@cS?0u{q_&fHeH&{3A zfUD#9T+z);mTF0tsPIxV{2nj-!>>U|eWHwWq7v`-w#ZIvWdHBqih3(fUw#OzM=S;8} zjGBDB-1P|reb5IKysa!MYQ(Uo)@RPQxjrUb&&_a$>tWyyuHVP&bHjM$2kzI_1dl7Y zG8>ympE0Vj2?_2*w%K@l;*U1CnCJPs!+c_6@De6(h2+rD3qoP}_Y-HZc33qPh%Gj1 zeBEoBP$t)m!RK&ML2c@U1!lA?;;sPeFO~;p3b(mBTUM!3$w?J}__e7C>*4NCJk;KRtXi@gPQ=N z)VWH`D`E?80|l1-mqj*eoEUshx+uLXePjbr^F z)R=X~6Og9hUvL(^eP@|bqM)B;GfL!WLL$fIY-kSm&bD63JKORRo!j)zwjyIRb{M@e z``$K)@ANB-+nuF%_GD#+ z9|Jz;2D@HJYGp8oXxsShQbVX1CKO$V86~Qeipft_OfI5xnpR9orTCg$W@lkZd3235 zxy&w1V~a+$LF!d)9K@UDM^keq;Y2m8t(vGbxs4Ua-y2OaH{mPBSMwoGN}eNF%9`jDVx|PJ!mMLF#^Kx8+Mgx}j}| z^M1r)oLX&%nXSi&SsR<9e0EI?21xy&jP!s?nQN!K(N1ZHos%tBS*KCk3XWa%Vs}lf25R?^6>+FbQJN>$a56Nl1sa$pTw3{B!KKnjsP>S|?Ei)>*R=iTl(kwy2v7k62${%q1^6Ec_jCoo@Hr zh)(yp;65s{wjKi(VsMjp;pqxHx$wB!w~Tj_Qx~=i^^}X@ z1SWWMJc}bSh6~8)blhJbQ6H{|e-E0m>|rL2Zj_VZBsePm4!e*9aiz z>68gMB7mGX(gS0WniFyYvbSb5Qr>1Hr1RHH`k>xc zqc^4HN)765)SW7Qy~dYV#R}ASn82-01e8sBN_{i@4GmR=!{L*A@JOR@WRdYG7c*Yt zn_`X%&DKGsuQwT^hzUOtK6$O%|rqDW1VGzdBAat;q zx{Q+!?jt{f@jyTuI=NqP2!YiV0OR#1^FCx~5Psw`lurrBionKYvLZsItcYq6ZI4)e zE+he{7ARTkt^0<;H*bt}*aDiYXi*w2oG8j`!)s@U3o2OQd4M%Om8gXV+^IDdfzZJ$ zExZerA+GoTfSC0hSggW_+2*#wKZfb97P0oV6P@H6E=JAI?0FDgg3j{Bc185mY6gqFt#N3CQg62$bo*oawqXlZfp$% z0@Ehm6qM^Kvh>wgkH^gwGjnl)HN1W~mo>!5iZ3jav1k3Q7`{R=NFMgqz!{7%J3V|0 z9spYpj*Z{IG9Oi)7fws9&aYs9lB`bsaxCU>C2t!tT1q7bF2u1Yu$i>Mch>Vr6<_(FRPpt!%G4^}^k=E! z0eql}uLq@S_oX*FL;~05!7FVnJ=i*Ny!|T9!D_ATXfkZS1drpC{L}-oEraw&5Y3pS z5;Nhb^Jz=bdZIsw&cpx(8J|Ovfdfzm?pMqFE2&co1aqx(>5uf#drrrEVV}lPW(3DS zmB}^+(Ug>nDl^fYs_f9!2*C$^-~?EbML2%bULeQthH*J7^G#fcH354-IA+HLPUS9t zzVDnOICAD;hX@z*Ho76XSy&r}Md831o)s1P2Ne$YNE|12#!Zp9B@)MO$GGbx?p}%G zG|spo5_g}c><;v2EyBZN@l9@Dy$>ygx>lQW73ixgkt}WfF#K2(*@_$oNAZ@J=YAAk zs=zk>FiT5YSIU?2j+egZ{!_6_h&$^M>V=RDAya|~VGzlk zI2r$^GK4{7LXR=irj5C+6d?>E>b-}(zc?k3JATr{KrX&v5GlUOpF4KUQsh>$#MS+Y7I=T zg~tJ&iMuiJH3)cc(3b-Or$u4V(>BVGgXSeWzPCzd#1D(3v$2qss7F*3?8h}MLm@@W zlFqzrnBM=gk%0kfHL4p3n<1`7o%@&vGl8rSVI;y2_EmME+2ORHFa82S?e$@Frdnw3 zId~9ln~DV{rs@u7PMEfb;0N3u`9#~-M9a4l7PrgLcSWgwO@^Xw9tkb4_R4-LT8c`($@?>@=h0dUVJ=tfL(0eAB4$WR?D%x4nPc>!0FJI z-S8Q;WyMRaf#5-9?MI0oios!cpw_4uWDFI9bi5A5AO&{n|JG3dp>AS;i7pNEU`xzS zrOlI1QEY;^_J1XKh5erv5mQdv22fjgx8P_yZ~y0A+ma%4;Oh2sVw< zMQG|gr`WmUth=ZsY~sAeUh5IGeUTBYU{?3yt~|*&MK6J7UV&N`P2KxnJHo%(t+LtB zE|+zfu0t(C9PTPV!7lEC@;0>0wN9n5BqT#h5)R}4b1pH7!8tmNv; z(3?nq5Gxq0wGgFLRJu90lA-={V|Zwxd9X``kL_HCScn6?bVFcz$DnRRKTny0!m|P1 zNXI7gkgTG!$kG<5tdEdjbkDBH7_71vp?GV&H(5X1n(rn(H#C^a5x4tEziU$tQ6h@? z#^blT_uUGxW>ULfcrH!-w6<3+|Fuo+)2cD+dsT9j$Un1>RW7Z%(V1pnk0{K)Gu5stIX!}`7FucE@6g{5D^kw9)J+!@PLkFgPQVy-TpWh2`%#Ak+_Af zAF>}Utl{!R1&9SttPq}9$&;%`^8{gz#S>2hyb({3KBcf(h&O8osIHH&3@UOeBiBnL z`-+OpCHFjqNOUq>7Vll!-y7EEO(beF^N|}UmV!X&>W+u5jw_>-MWxk@{ILU(x}(H8 z5`+gG-V0bSJtjTSMearcnZa&$lot621#*}*asYw&--*LkjvW+&cgJ7ChZMZ+9lWZP z*@;O+dQ!c#N_y}{yQEsAmIyCPL8ub!#=V+iVPL)bSJsPUqlE(~f5LBnc|^V__~&d( zVHNr(*jg%ej(|v|1}Dbhri?VY*vN?jF(eIx z3RKbRfuZ*O2@Dm*`pJk^qGHg+Vt8Qe8wBAzA0)B2y}g*3;6$aptgQA{;tS-gf&ad) z0~P^8kQ@e|N}9*Q)$1qPDEP2+2ei!hPGs5sF4h+MU#x0#R%j=#`QCG?d%9;8yvg_c^E{dEt~#~7b!t0x z>J(O2q}HCqzP5TOx@+_|05%%?ygYGKpF4w>8+uWK#o#w#P#@*AwxZQieVAG;D%wAYe#ll9Ry!w{{DTyqmi#-Ej?(9mv7yP| zVoJWFD5`petV?i%^VLv(fsU|M{tAcCp+XY8<&nvr7w2qh|{r_IYyspNT^AD$mrmHf_-8q+c>!7^m4UCB#F#}4(}bx;>~4w5dehf-<_ zXb$y-%pz>OWr^uNitE`A+9X(B-)ap&W!nZpjxC)+S^L$^+R-wcjSu$@XBU(fBli%J%PIMf zvg9A9%K^CW7=D5hI`}!k5JOO>m|(DMjx=Gk$X;n9WOI-RLzG6Va~~})h5X7<7F(3o z1%A{>g(z*}w?R=_@)ssiS^}CFiPGMH^q!;;htyLZr1qKI{w8XlEN05uf%baeDB^{V zzl{`9rVfbR_citsMMl;yh? zN`?Zq*9v$Aa_##AXG^g?45XP7rRxx9@FyKwslg zKwxmqH?Ntw=HX|B6iut@apLnoCfOBcmejy3?%u5s&^vq_2EQ@r#OXM+-TM%m=z~)> zXe6&LwW4u9D7Bh`4{dP3rge#b9>#AbKy|Cfp)iMbQ3IJ3mh;e0SO;dbcn3K$u*YWcPO%(Ben0B6! zD8lkqP!=%|ElHC_IK=KD$s;TeuzPet1l=pIA4as4;qFRAkh=Ezpdg|pxdc~2WY&Kg_{`0wc*!y7b|b@6p9-ouxLe zp^JU#W8x!=dl&IqgzvT=sBdbSzs#h}Kyg~-t?G2dC+7p=Ju2x>kj%j1!S$I5x;}%& z)0&IOqA#xWC$=9C_*A6C@(67`XhyH}1LhB17DL5T1M|@$XqKc;DV?S0FigdFCkoFg zL_Hdw1O=|*MO41u@uQE=Xb{vdV~7ck>)Sk3dgo*m0?R(~1teR*4Y3Mc^j)yf(@6t^ zBs8Idl5ENhHIP@gg$hd0JamA&0sN(#XZ?5L8X-M)rJK_oRW!@ccJCar(W)iqmHn_dL`U-T>TAUdA(4 zG)Pm8fHCk&OA;)9OYo4F)2f68Bo7gRcTG7xv|CCYCFmx-n#@Qno%@lKzEmEAe5k8Y zuQbSblg}PQ+C(i;KNKkr=cVJ7QlWEtRBPgu*2laX%#}1o2{_ zjG+2L8G4EmJ|h>(WL6=ru%r!c8imoJbUowf^UcB%Q@`g=?GbJP(c`f{1d8T1h^07!B-(AcCg6rX`Jf55kFA%%6ZBbGq=I$sFSJPpPKFEGBcS zK8qC?yGS&)t|YzLBd0d4!?3)_L?p*L_x z0nS45c3{B_oHd-0P6rI3Q!sM|9Wk7V4M5rs%q_TM=B)8f=o>(%V1Q|wcKcl9M@gRM z2%W`jxsGQsd3exFWIA%~>w~@^%Bc{UoPnY>GJ~U`(ge!y(0q;ownpw_5}lCJz*YYuDGj&sZA`*RxvpU; z4O5BIxzDHesH|b$e4Qz&O(lX73j!*Uo=aUyLmhBvqP#RJi zCZxGUJSok29C8d%8B&@yBFc0XG4DvV>;dBs@x^->;;Ve>dCLm9Qostg|k-opGXP+kFi*qW2%Ev|-( zLq3WL-JMfY5*FI3D-$8xEGx5p1uM>2N28@xvP~o$TkOoct)yI?w;CrsD|2!DiH<3>+OL}uJ8TVNZs=*aq)V<*$0+_ z$}z-OOLgl|2z1Z;arV=WeUzI~aLy3!;YChr!QNW;>+eB<>~*k%jz2tET#qMxV*R-o z;l8R&bk$FS)QM(+#noAj>aRuUR1{kpiUi35nYqiu$d^}x?`lHHN(Y-^s!rQ*gN^5G zOlyyQNYh#uvY1y5Aj+tLR-M-Zbs48hJ*o%c=KDZfPq>? zorgrN_ye6O<6`@nD09%YdLsh_MCLIs-rEnSDbs<#qXk}v>r8BU3&j2ead;(eF_ zt}Dx9wUyOEyg=b@LpTIE%M?WORA(ayw)8k5Az7dRJrIC|4iPD7B9V}X zIIs{jP~ZbK5vggOYBGYA*;dHQC!(-c9K%*@5J~l}kX_3hvY$$?@H`^Vi**z&sk#px z2ZkzBmJm8?@|KxaVRRk@ z>FihMeRY`i^TlzHJZi`|2c_9Q*`BMsK-q%{BJ~T*oW$abC;5h)H1+`z8YU!hKqPme z>uIs@T8^QLHin!snB@eQO|(RtLDSa*3lUU3SwNc9puP^AaeO5Vyb1xH*g;%E zA7MvW03OkpzFOm)%7%a%mv zji}=W5cq9~W|=7(dw4X{Q4>+3;oR`ztsK#)El^c-gh7Z+z}DZXGvDQfyZdd#9_IBt z#QNy&p@f#`x|ZfcgQ5PQYj5;}by>KP^2XfHL^rDleNV+c4w`R=k)E8i7>g01!*PJi zDbAB%oYHbY9SbRL_#lQR#SKd3n?H~W(zNi_rXhs!A%{4p5Ik7YaU+B<^>8$eR9dv^ zMyDuM4ZOMkVgr6u-uHi`!NgRk8I&9!+Dven3iZMPPC&Z!XxbHi78+W_&hP%(G%feI(ot}1&^L^`8JeV)ubTA|YHe^kBf!Y22z$ep#aLu4FD>?R#o zPn}D%V@y1UwDC&Eac#mZJP(#0X=y1XJxj6jQYV&?keB3++7a|U>h+kjU>gcHH}=T2 z%BU@B!^%@=c6)=boaX^sO6yx-D&QK#Q8cRG%G9`A7VYy_{&eEx-5$lY1x*T?l6g20 z6?QtnceH^9y7)9pYj7m*Fif42jcG0Z8<1lpSA->Eik!C!C)=SZJa~-rd@&Iv36tGB zC&f;->LB!|OLh44YNkIM_N63DQCAVvJ3c;)6R44N&eM&J1rdWk)s9PzN)VU&A_dYl zXL;|{;-(|7xT9Kt0@Fm*7SA4TnIZPnaIyrof4?XLwq>zCYf$%K0fVE5h>`Yy!T#jOJn1t$soF=f7vkOIHt`F5F zA5ky-4s3l6>}N&w9gRz(^y1nBuq&&!Ae;PkmIr#EFuwUHX4VdDwKPnEKB=jE@^%N} zZf%rKxq6wgm(>o1L&+$U06SQ^f4okmbDkNI6DwBxpWrGhJttU|i=4nt)vN_!XHIl^ zzrMb_afFrhLH^(~MyM%_n7^uB2Sa@w_9LL9?r3>m`ujC-S1-Dgdo^B-w6t72I1T?J z@SlVKUieS9T+9Yb@u&bj9_8Xu!jHj)pur%XJgA?LtU;)aoy*(}komP^!<>1b!^C&6 zq&;)AXSVk2r9CsXXF5IW29HU>1HlUE6VEBybDVf`p0w9Wdg4#2<1A{gGzZdNDaZ6z zS4z`gGGc^n-rZ;tyEWlQK)qlGsh1S*#{6Ecf%%Ytp#tt5%bSyROb=e1R0W?qE&fK$aVZ^paByjQQG zpboj93T31{{3BCHfKpHit3ej`O7IwN+c_q!^R=Lh#7d8(%(4hI^iuU<&NHMGP%HNqLBHgX!Brik z&E`9U!g}uwNEaU>Z{Irdo|KE%eR!pp)Zew2j>qW5GV{VD#DQmzHsaZ*gLn=&M?6zA z@FabB&@@c4T8=jywA`Qc27X4qk*2$C#>-an+|KUl_`UUwUhHc*zJ)z4$G>5}9QGTb z`F*MR?P9-i>{kd~qV!3Y?mk(S757mH&8i)~Ka38FE-#F(;h^mOoq-s%_U_tbh3l?MKQvWlF zHVANxv7jFRHMn2uJ;dJtvxaB_w@i^P#$_No=AF(x_ICAov>SWk*F>GC6sPD(mLN%P zz;=auEPMC&si|1p_fs}7zOFmmQhL|aX0}SzgU|TCa?hm`6VX*#O50IZu0d94+ny|u z%f%(q)b-rn5=p5Er$U~luRM`}qu(FSi>&XFOF4}sW7eQ+m@nv+;xb1f#+TwUd%s<- zZ_$#3B~X?|(n0T6#{mYTzGN1^VJ1+abeJzGt{SDoQadiyla#y1$sHb4+RS&zKVe8H zaZEiz3Bs`S0C--T;!vKUZ^zUF!ug!us1ZqilP6QZ-T}kY-nqTWD)oTQ>i60wnWY}k zOWi`BO6~yZIytvD>{2hMFwV0n02!tpP&gRwWSV*anaaK7lVfC>dI0qdgJpMbdcwf; z0P0k)!#6+iU7>yR6W`0UZ+_yNs)*?MiErwe=$oHNl`K>bC}GEkdW&an?;?fqk?YZA z^b-P3g%PwY5WC{VC93^H?wM<-M~0{s64uERQI`eUn4Cipu*7FDBW(Q9kGmZ%ru71m}UJ>gkB;&b)$=ZG(k9m=Z3m42(?;_B|t<_Ru` ze{Dl});|Rb>BCR`ufuvfz!epa)Ai-67zhEHwMZI}G@=RB~tmN&!!H8$@ zIGR|H$;s2W8-F+xlRlbt<776B<4`wFnv40=h^s>T6Iw8no&2BF?~nn^V|rq(nYB@@ z&&c_@4LEjy@lzQ*ZitdpsY&gzI{iuQ1urA~<7wI54s5 z%}<1df+|>yo{f7;4ng*TmROI-0wa1^6YGR#V*{?`!4*arGqFK}d(3#_s&s>7;v|#3 z)!_OBCb`&(8`dST%C=GUqfjK>#^nycGFSeEv?GCKRnP<*>02g4=EEZV{50sQcUb3d zDQ~m9Ucc^pT47jnKa%sdz#W=!fE+tT`_xB^c_p8teRdR|t*xcS9a`Mo*`KMo_Ym%9 zl6%Y9)UiSWO;f*Bkk9nn>bzN_vkAK4plg%nk~G)XzhZ?%Y&Pk^meWv6jl)(gd2>4l zq(eKT^R$%~MVn9BoES{j&rVvI=mu$fT0tPL#gF*{mv*X3GXKY&dy+)cLAKZ~PRMA+R{ z-*3JDT#-d2@7e-SVoPPz2K5x^fZ`4v%VX<&koC}V5qO4T=bM0hgwF?sey`YV1Xt5d zP=*#JjQVvMhS8jMj%+Yf(0goXMZAQ%dgx(`KU-XgqnH{VCd8 zhjnU8tn;n!6AR^9Y)1g=VR1a)tlXQc+?QtEyx%&1501&)@82nO8M1Dp4m!djLN7$6 zwq!p(uJ3q*bs1n0Vfz=7ICPOEoE+@U<4rkBWoDA)xat#d%>u;e!Be|h_a0Mj}WA`NorDN44cz~=SpT-Wz zHZ)7fHD*i5eGvy+LdISR=z^Azi}3;Y)K2Wr`_t08AJbvjxAlSW`(j66Bg_%Y-uVEu zCAN3Ie-^Hhbb!15M|mfD%L|Q)?CqvgtxUg_YYaBc)9MCyh6~Dh za^}tdwrTVANX+*IehdS&;ik<`#H{(pXxqNas9}YeHP1l7$N=rM*THKicD-uQthr-o zgjw^D`ucyvtT~wZxtj%F-am#XMB(xaeSDpQ^9q_ILrK2>Vrma)3$_MKT<1@q&cWi| zhkD>;JlaSu)}=4MN4<*0{biW@Vz`T*h7agJ@PL?ac#FlPgr_mTs{X55V|uiv2(`jp z6+0hQpT8Q;VoCJ4OQicE;@6xSH7DNe!Q2W9s7mU;76noeS)X@a;%(4!_1DqZ$6A<< zoy!zV37{w>CDJs@p-f2&Gh~O)G{g@T18nblHsTFR5}1nnKA}{VWM`&;0;k0+9vbFE z;Yq?)x?zejXYsu|_%uD2X<9B-L}4wRo6(^K?(d-JM7gpwZ%T|Nh&F%+r*8V$atASV}(RCr!jH@TA!go=yDqwUg1btdnl&RGKjHsQs?6kOAeHot! z_J2k&=SDSy^IE62@&ASiHFQvL%SK0kU;pJ;v#N)F3OYJ*(;b#G1r(*oiSum##eSHd zMHnQ}L71@6G6~fcWb#aapmrLijSppNrk)?nH;|t*DLK$JOOk*cYgFUP8A= zc>A3G9S&-U>0_gM5I1sJ16WQlX>R}LDCDf&)`ie0^16(JW-jfZ*{Bq?20=t&kb6!* zDWJKqdOHx}i4Y$(dpt;{MQ&Z#3KDfA$~jt;qf^xBLE2!H#bDcj+D4BOCiFj0hXl#A zC~Ivsr$Rhg!~L4t4c@*dF<6ij4dzR?l4es4DSnVES>?VF_3PseV&a4vq2<(|UJYle z+|D<0x34rn?mCmF5;P|#j^_W zpv%OWaO~m>qo8*ACY%dztM`^+ohVx>y4pWjQd&Y2t%fXSLu-w0Fbb5D*aGeT?Weij zd+9;yI?Sb`;b+3|FtCd>qs}c3Q?N7q=jyL8iln`2Mv>McBnqlNaXq0=^2N~hB+hR- zgd#Po-3}-ZXfA^TPAbr}LXIbA;X!EsV{v;QHDe zs5NDx2P1W*u>ceYIJY8^COE(us}Z0y)!UYo@p`B0ljj!oDSn^=0qo4QeNUY@*=RNJHEF9oEKONBH z*pQZt`qKy|A?(!WnFMN=Cvo6YLp^%>ODIAu{f(56(&yQ(q3Qp_lzs-01BOAvwJtlj zzSa5bMw-jpl@%jeqZ9V79fJpnHOD}(lukX!quljgNB6!t&o;@IP4`RrFMzxQavNO6 z+!=Qjl&(+X@6&?!zm3KHZ{T-ar{Su!m#!U$G!h_>^Y*y_8jzI8!w^;Bvm4Z`=(7Ri z1wL1=;I^i=Ll=%5reN^MQ`XWwm6XHtL&qP4qlpw9g`!(>Na(s(@}9d6N}`(AB_fgS z(50e8-W6LJ6etZoNMMS9piqN=FI@@ZrQ_kI?m%2b-BfrKF&<~4#O<}*meTz`w1MPv z5&Xf=^@hAyuRrTZvZI@5F}Mp%`kPwwAt^!Go_dB=176*3G4DrcL7}zqQ$U{-x3V+|(8mffR&;}h<+{z$OP09nRhayn@8E8_7 zjn|3+Eo?l4{ORxGxw1L%JpNT|JR6q8!gB^nZ{S%8x_Ee&!9N7gLz^P-Ty*aOs1FgeCro$N{r&zT z3v0;9wHLa_gJ4~@#-)8S0DV7GOZR``eDIkYAM&m=Hl6g+$~JpL?$e+Zt3aJ@;`c(kg2R6Li%nee=)U(@56bzL*?=WDgG@hox2!m|t5#=vt7 z=;Gm-4gU~4UxET|7@iZsfKm7}56*<=#o0}d=gQ{5^ETKmh$ZjqRT>M=O(>>;XA0=z z;i*0lhUe(_BJk`028@E|pTLpu+;(Nt5F5|(l2~~51lt&RP61s!JSF&t;Q99I z2t1u&z$pBg4`;%&U+<>JGb^td_;bd(*m&mL9}CZ&D5imDXVAsN^YFYdJSSI2;F$pi zjDlw>oC#0gT1JV2pJc~dV56?0155cqU%?Lc*V8AH+IUUY~r@dFx zDlynW({u! z{_Oc)Y&;Y0jfLk56w|pk)DtcHIGp55Mv!1IU8qT=}poC(jDdo(?sE1Lt)o$tiP zv#KZ-p2N`m3_Qy~7mq)uz&`}fuU1Cj`6w7L3V#;EneZHYY18AGh0UoZm(MR+9UISa zu)`F6{&^h5H1Ny@T|7KH!#@Pi1yvDv=7IsE;MoJtglFsSG4O=3;ZTi}PWp~wm}aX( z8PyB=R+%`mk`6s9m@LgtGwY#DaL6Mw(j|E=DWEws(j?qi3B}HHa9291fHkTQ0DfaX z_2QFI1%-Z!Zw59ZOe!i*v5JZV7pXxh6sp&GRje3#CEY>q9dP7r3l8^|Km|tVhXMg; zov95j!Wm`=L}*+8e+!+J9i&omr$92|3DK`hjfNdKb9 zL=2){RCFjT!h$_xpx6LQ64{9Wc2&@MgJ ztOgoTAAU`*_uF-C7zZlWcYTE3Mjtp+M%!IX^={g44(c0e`-j=FlzX!co$~c2BEp=H8ssi^|wI_qpSFS zgNCHOit?gD=+qP{WY26gJl0ayXsPNPN;YXCmgboDYOu-s!+EP>_lF~9#p)0Dp|nPSmasp9rRKYzfWKD~b!RrC-RoEA#10|%7T~37-ma3svMh&F4kW_OEs$y%hYxL?< zphQ<+O`u6eJem^jJov^|_|xMUBjTu`IFcgbxQg?I1# zZY>)wO8~5@ognkFEk3mv^$K0un|>qsSeKVDR=be1s6cfq-W~F8sPa->n|e7qXg7p@ z#^4A2z)57GR>aQ*IGVv(`21jK7M>($EeoSK3y0L%7l__DPXGKrwC``PZ-(~0qAGU# zE}RjoeYZsw8SPsFUA*?43ICAx{n$$p?RzBPj56ODKq!OF&OASA`~IKwkH%x5Zu0(e z*z2+JOrIVL&$TF~f#>0A@$uXW{}4Qfz8HaL5?C<`o<9Re!gFJK)8lEq36@8jTA%j# ztFiHHxHA@>Gf;X1&q~n6^_Ws(xW8+!! zk63ti0oxdOjsaafJhR~+g6B)mMc_FR3>bw!^WaQ)UfiYW@od)|?fte_V&mCsYAifA zp_m4qDWHpor#dAJ&(Y6D;MoBT7zNKifg|C$?VP5^b8&Ov+4f(t@!UN*7M}A^dIQgD z(8a@Z8T>=|v(+;Zcy2g1DxR;xnedd)ZhAc1HOKsYZDnjc%O}OcvnSZbz;g=d;^8U5 zKLpRWao#a(zt;%{jKZJ!a3(zaoz?VsE^ZDyXW%G!to`1cf>?O&L@^CKJA*DBo`)xf z;W>Fl1fCgSz$kd8!kO^&b#8h*+l_37`4XMmj)mueJ7VFv2*ot;tOs2@JS*WJ!k?X% zN8q{T%&2&-fivOxc&Dbvb8&Ovx#{`Xcveh^h37ytKLgJq(8a@Z4E#gzta~y7Pd6Aa z3V%+AGvR4Jqv`Q%H>w%d5aDxROfnecqM zebeLF?xtqo&z%*q@vOQn7M{b<{0uzHKo^fcr@%i1&#xYf!1GZsU=;o=hBM(g_VlL5 zb8&Ovxd?^?V)5s={8)G%M==dNvq2XR&(810O6@azF+!n1X|rpL40 z=w{&0fjBH43(vG$W8wK4ifQ1f-Vz_rdiaOn*>_01T@$uXW{}4Qf;y`8?o=IT9D0u!190|{jr!_sE?Z!3(e;!{J8_$NDV&ORh zr8n@b1YJD-EQ5ato`-M{F$~XDZKC429L|L2J*PH3o{O6U&(|J{jc3WISa@~;+ZcF` z0bM*iv*90t=Szzs@SF$+jKZIJa3(x2Zr${Fw!66*`17`or z;m=k$kQs*OhLosyz6xi;Q$D5X@oaZXGw|oyM`Ghyetj%FdxC8YJg0yz9-b2XL-2eX z2QtI(bb5tKV##WGa?qAJ5fvn&(5HWhv(tpVR%l)fy^*G zGr)jR@Jxj>;puDH^mw+rwHf%c%i`F09vBu2&qXMvfoDDF;^A2d{}BG{gaesjcy39G zisu?Q6P}N^XnH&sHwT`Z9*&J?MP4jC2cr2Icou;!9-d?1AA)DygAsVT!GKZtb2^*} zPkUn1;=5Ino#KxP=8KO{uO^Ak7|o-ZG7 zdOX|R)(rf)Q;Cgdl|2@o!_fQ;Jj*~Ak3XltKLpRO9*Ds6Q7~W>{w#(w;W_rtrpI$} zbKtpXVQf6dNwM%ej$#^kW`iyso}J+zg6D$y5qRc;0i)pA1I~nJ>tjuiXS>^*fj){`QXI~u13~TSd0k9}|egkL1bM?`t$8&LW;JI%>Y&>gh zvGBYN&CkGd8R+8iXA%5E@Z2*m0?+6Fh>E8d&V=XGBTbKIyK&9HpDP}Wjb~wQEIiwS zZ45jm(8a?u6aFE1K2{uo=SVPM6#g6lXTtN$!%dIp;^x3}m?t)#>4Rh8xfaDV@H{*y zKAv0QAA;vl9LNl7?@3_5D0u!190|{jjZKedyYbDypT|pME-oUdGbn*DJ z4E`Z_9=bOI&sB$_;<+5ogy%iKH$9$G5ngp&9t|w)wH~>~&2nJU5}32A(OPi-)H=FbvPpIFK3E z-aCK+qu}``a3nmp{o3?+E^ZDy+m^(}bN7H)c+NxV4Lqws7Z1;6@DJh7RydFuhUbQZ zQSp2g&V;A@OVi`o?v7^Q&$aVn<5_-nEIfOHZ45l8fG!@M68uB(eA^X)rxOeqg+KG* zOnCM?(DZmNZVo(W6vxIhr++LwccPdEo}ED#56{C_h2c3F2PMP!GXo451dF}@JfkR`C)p?Q{FDYSv0%ySQ$O~eQ9z3gtL3Nhtr$C3AEjdcFJ8Rc|N6M>nsxl9aM~qLlOM zt;)!Z6mi*=7YCB**zEDZh-{m}C${ORH14Ry#qCvrQMiK%lyYwkq*iqprqhRU*zgH`q&SlN|kiwRnc$oSrqnWut4cD!eLzX20hh1xZIV_&LRU} z!>2~gh7S>UU}9(!#W`Pxvwp{|%7elBSS0FWZ6&b6T@qFF=(o$_z8w`)XWN3$1b=^| zvP}I9RorN+PISoMTik!Z9j^82d+b_)JG|(cGT*QG2}$3ow6ZJnP=C8of2~qliYu6l6M1{fw_p;*rJuWqB#3eYW(uzPiae-a_8mv_Ykl5!Z^@WTSG>}86m>v0a?bj$= z|CxI9DhnvLI=rdB;Z4nIPq*Zhp=ihG7^YTq4;{H}v{i`OuTtLy=v9fb4fkVr%|%MM z?Hbp7SUfG61sL9v;w=fx1b$Y7JEV?YA(()x0ZcH)bSjgpwhY(qP=c;YC?(fGs@*Gp z(pX`cIuvP=xAR+#74Z5cS4R)_LFPWueDL}Ke5%y;@S$k-`zRV@mTm+|V0kdxH^)U* zIRFIrRPya{&*K7frHJc-zk7E`NGL7BwUp=MhN5v&e`yLzL>D&K3hU>-(qXN{jUV~z zCGUXe?;uqB+>lL=)K~EJ&f}@L)9`73YAAo`=ey}P5ZG8~CE>ozcBS{Hv~=Bth;c;) zUjQPmu$+OwfJa=N)qvB+yQu`VwuZJ+^$gdvX@$;N@V9NYzMTjQ0u5AJJ4%b=#W$_i zj~BNTH&3pqhJ(`aN_v3oCdBNYB2r1gyPkx+9frl~dYFG4erXEu|YpN*}*1QrgS4hy%BcwuVF(E>zN9`9h`L>U4PHYD?FtWTGJ# zQKIo9f6L%ZE|;@Qy!M?9`xdZPA9;CMsC|Ry#C0k^=$Dr@s_Q3_eFOA})Y5R@#|$*e z6T9!jUW!o0CU1E08+O?YK^uP=Rt7)`i_cn<7w_K(CUQSTqX_$QX5$0p})3h(%Y8R=OUK6~c2L z!I_eL>3ib2i2L?V#=cHAYDBZKV@r1^`RMJGWgSMZ|4tz zo7RK%VbYV~&z7bTrs`+@d>U~Z{JE`%QT^x`vvu=4y>#G z-LAi?56mZiKY{tgyJ6R}?NhIy?8N2|y~623 z>$e@eegD+zm!=gZIHxJv+g!bV2kb`u&WNbri{MQ4+hXTm)o&Be50-PS>+^%HCsFGs zH$P}~XO#KD?#wvt@jd~GR#k5@>B+RmQd5ZV{c<@4l6HJxL^MQvEx4|kR%#H`CBitzq7}syyNec!$U% zTHm6#sGvNe7WE!Q9`QPyi9M7rM2o`uUGLw++f!nc_OytDpHzFAij>fv?tUSxJ$>^$ zbNNm5K!)x{%zAsu#QWc9Pk}9*Qk(FUW{Z^eJ||LYL$SwhPu?$0?P(&S6z!=R&eWc6 zV3*kKY5rc4X6MT5t@6iK`AgY_yY2sU$lf9>VsmkW?oQlMjSUA2_I_ZKu>oHYO#54D zf_zBEm+>|Tgekf5cWTX>bd7y+mF{Mhcgfq;f5A0ZhWOOGTtc*B--HD)6y_oLI=pX= z(|wp*5!+F97RQ!+!FjZG0%5%aR&moMZ}PKiNM)ApY4>tICD{>TEw|6QAuJ?5lukF* zr;4xQ63FD2IlQ(ibs;8^xt6zVTOiIavGE=EitFQC#nq6DyEre!&EJi-l0?_2Mh|5w z(REv+hw`21`Uh{L+-=&pv4C3uO|INXMai0+9Q-<}UVtyyNF;nst4v5j%GIr?6)kq> zvy!r=5Yema*^yInE`{S5a(s;(X=7#~0@kQc^Cxz6=KIT7ih_Jzs^@dCp3i*Fr<3w& z@s!b;6&x#l#=Jqvk2NL#k-rT^B#P=>qi5zyQ)X6bBqD3i=~-*9XYDa#`{*Ig<&n=R z)7afw;7{dTA|GzzDEL;YJK#$hdV4cvC`{fnf3JkvA^V{)OI&Z4HwEp7Vn1a~I>(W0 ze+ErM*bgOxk>IOpdX%#LP^JN|UPQ^ja43q8eWxmfB>SNQpAFg%ZGiny3a;4?72(jb zfs>@1`#Yt98{8#XL@o@1Qe?0anu5r**97BLHzQidHcWNfp(6nkvQ8;!wnG=5!?r`K znUcSZlRu>9eM+1b zb$u{@Z)e^${0+O9>bGZt8{|5xjS&3N?)roI?1XGPjPsYyA84=_%8}|>r8H^hq|?f8?nZp(_3SY zb50Vy-?gE2g73L@wC_E?xM4BnWJ!%pnYbW@c1)=vv`y0#i|2_XWC5F|dC+;orm4@1 zZ&M03WoR4por|oN1mDGAWvgm#q(SDgal>G+=V6ck;^h$r5Hb}&|quekWgCOFxlcs z1B!sAjpQvZ*JD(_ekvtlp{=|UUCN6nDwt=PRC*X+RB+!q{8$x>>~$a)R^@iUIy6Q0 zPzQ^*HX@^T?^`vvW;suJt)3p9pHY912E91~VJz-1QCz#XINEr;bl{XV>>JPzwj2qTFkZY1G_jaCeooPh$Ri2*nx&rvb|o1ahECt&vfnCnV(4+ z^Z+kEk%I&;_+Mk0L9u)jnr*a(!Bm=;kx;OpB8zde29bVf7MD>hC83dPa8(V2*M-m))jJPNKG9@BwV0W3CZU z6Z)cwzEwk|ft`P(*@Yr*)8?;3)?OJFa?b#S{Oq*94*5`c$W%;|e9JgwI5RDwNLz(u z$7oMB<^DEU^*3NB&o<)Bl`qY(%io|ZH&fs!@e(H@mJZm|zYZjH;Xw*-9~@E><^j0x zkREN0$cJbGy5_SakgU)8O#l8oiCV04lC`8bE5UiYa$V>C*LAQwx-Mm1$&p0YaBHnC z3$0X8%j?zD%aToX+Xi)uUN-eUa0J!VOicFNJDirR&uALR3C_I~0T4-|Z!8x)9FrVk zrZYl-j*3Y}pI{9cm^{-3f!(K4E#01i1TjzfdNcKjb5C&&6yNV{;Q~vZ9nMRY*(vX! zsdH9Gev(8p@y=$q-Ir5dALKjZp{s%jFlGhHY0Bq&G9-)9`LCpRFpq-&UhI$jJ%n57 zBb!4hdHrGb`a8YFJ69u?-vNM4=_b0!(L6Xwa)UlNooeyqBkwdg6_P;;dA)LDnj>Uf zVd4DeOH&f8)tFZ#Shc}{>JKB1Lq4KTaVH=D6_Hc zcSs!$ZlVs{eHXH%gOdt}77{ri9#zjm#!*`sDruk~#>13ud!T$7iUJjvn>x_yMNIz>*3u+L z!jvwrOj1%LWd!DQqe>*PK$GfnxTnK21z|BWrQd{wTxfY+gRc^5D{tO~GD{ZQn^bn8 zz_6r`=( zJ(K}_6z~UuA*PyBC||4UcmCUYHZ z-Tzm0u=LTmb@18gMjg!ju-WV2bR&rquLB!Y%D4_TZ3t%Yr0SqG`nO;moX#I%bl#=uKGR%i69x?5Qf zqhG}WkmiN8o-z1M$l7QvJ=W5BDt?nJo+2ppoWf|4d0xZoyc{?cMPCPW^2$$x^tDO5P>ZjXAs?svmS0@-}tU zB*DN+$!?C;OW7ky$hce#sJ#>~&B*adGq^FJpc&i()>068Bg*u3-}TPI+i?vD@g*AJcC>y7J@!fxhAu5c)b*jy7Ow(0=ia7 zVU$6EZO}vNg2#_TC9(>A!xD@*jUJ-K#|r)^5+DEKk1^uo4f^1o<$b(i@U(ca7)tPc ziJ!=^tVJI&{EwK3{$p0umCxed;Jh|i9)R=21n&M6UZim63K;-(r-U2CKS8b==MMyw zoDPBd(!(t+3*PTa^_|+P2Oj!j&%Bf&8CTnKs^vaj00q*2@`HdHRj$q+NG0d-%i>vm zHq>D2_zR_~!B=Fdd{-dLW3imI&R<)If$3Yy9SvLVM^FwEJt3T&i+Jt}b=M}o$2uaO z-V~4032T8Q=uaWQmca-x#2nzn$A2F-ql^rkL^vD^L%8^p=y$sZI}S04`SNn)pN7I< zkxx9uy5PFzdx{120VozKfA4zqFol@JccM8Yx}Y|gwx^Ml<*(OBmr~6HFi!ndS@vHN zR+je21yWaBl@KuI%Dz1L&s>GOHT993z`WFB7?DQpSf4cFG&UkA)?K6;lT! z*4e7ue-66zOmy)2;yfKCV+=Ly=z)&pnqFL4{zt((B*tp>%BczdhkWl~n&{g>9i(?T zbu2vIKo(27E^Z~pbXvk_)5+SJhBec`ZcL|7TMIQpWe$zRY5;>N&!^8rw~YC;Jor-I z8F+0_Y5E2+jq3vBu05cjjxeiHs`~)G+GwJ#e>XJ&+S;l5SfO719to1mg=Tz(`plYC zZQ@Kr08gBulpmZppWB+E6|>rR5S2D@KEWB4HWOmC=`!_7B!vO&PT+_rY52iRnjlk; zJ#{3o&{pN}7ObpHbe;;iDkfc{s{JWc#s(7c3VL-wFbiIq&<1D6OUBWc?4^+__6)m6 z3a3m&>d)^43v)8700K#@0)^(B;sV%u|OL(4lIyl@BTgh5bz{ENvf9 z_S6@Rxc^4AEIq}jmYaexoz&vYsFtYpaSCD$&dTf1o;9p3o(BG4j4ht8g%5DVyhz1I z=^rgD?%(j@8;L<0HC3VBWmK)j{p7C%Bgyu0YAgaF6R0{V^?17|rv#UtjohQhded@@Arf+Vmpsi3>!HI+* zozSn)Jlgp#&(pb^IgGIwo3x2#B>Sg3-o&I#S>BoWgCr-$c>ssfzj1IHcOmzstG7|C zkXTXOIpja`JOS5E8i-fnfPJzxTd4;)OStpZbxhb=IFt)Q zi#y{eLda{D5%JH}*w}7Q4ut(KeChS+?nU%k`>ACQ4af}PL9DO7Dnh^o;B?kP;GsSW z52|wy4cBNtt&@W7M{ij-f&@PAcMtlg&%Q-vB7wr+Z&?nDt)M2XS(7I9W){hqT!GSlEqQ`Pf2*JievhB;q z4^Cp*&)a3}gE;dgrI&g*$EkD7^JkboxQN<&rNB zS}kddb|WU&8UFJqR0BeN7Ibx{9<+?zZ0XrxDeViQ>%6%=a7ORXmX-(lq9NM7d4a4Q z4v){WWWBFDImm&$^Y$B?H_qENj7DR_$9Wl*8t@QCy9GwSX&Cj*?KcA;Eujgb0O@o8 z1vVTXOV*F8-daTsB0Xh%avz9&N(ARssmFaGbaquw+zv49ikruHd}%y{3SMn zFr&rB*>&Ee3_Bzy5_Z?XSe6H#qilE`8I01mgwj&DybGifq}J;XT5emX-h{j#w4|l3 zXqA>=$prehZbmg+`hm0>MD$l8WvwHZ1D2laB+KAmq<;7sd=Pv;g4*gO>Bj>4-X8Yx z@;rbaR~(BS{^Lq>Zy~Iw%AxZ!uxnGIQi&EXh?=Wd_!a?^&~Td0fxq! zC%RI8#Fn2IJAHYy(GfJU>4;r{=!Hbuw1Sr~2Pc*!hIF3+2k@HZfi%46&C%BqAIzbg5p((v zMIideT!Y2|!wK_cCTHLj80Yh6JsKE=RL`>~_L;Db$r$Nx&Jpcfv zcy_r>hHoy)OuIM1P0t`4?z;q;B)9byA|_gaV-whO1sVv>$fl7Tt`bwA!o8TFWK*j_ zpJxcvj;hbiV^PaB7gBea+KnHYs3jA!$DpVs31JOU%V|+!8Y^OIDPsC2gZoz@wAtCy z6w@xOw2YX3s|Rmj38ZU! zvECx?<;Iz5%(Dv-JmpK*JMO?Ee0k?6=}nt)VmO|yc5ep^#W|bMZ|s^M>lkw zQj`=d*uTCKiVXArT!K&)CqHicAK{FJgT-^juXlzE>o7!D60O$ zOLWVN@NQaQYa?qOdnW&IOz5y-B1VVLyvhFa!9_x9df7nOO7teLArb)=ZG1SqdF2G! zUM?0zPQ!7f#q$*!z7T!Vpe3ZHK6(?fLj&0fuhIM@LO(;fPZUcpE$U3|`&28j(#9g4 z_NRi&Y_V@esfW6we#YqK#ZC-@kaW8jqIP&+&DO~G3yx5?J=qG*Ye-_PB}zhV4ZUOc zGI}&Qjzn)4dnSLUsRWK7^dz9y=7@kZ#{t<0STOl*jiQ%Bo`wT|-j3U^CW?_6=?-}! zX$~eotWl&%UfzciXW6{Tcd)I*h$ON&PhLU1LRAWr6Zv2$UUaf7omZSJhTn$#Mle)66f2COpzhiKo=AS$^LT82 z0w+-71Ol-^kkuktO5>1Ixx~u}&PWdVS!Oue9};l%A`U_QC%@g5;D8oOu>Lg%%#Wae z0E!}Z;C+i%uVTP%A(u$N7DC%Wt4(fP+_5IVV(N;|Li3}#M-J7!{~`~D*Wzx=9_YEh zBv)SWCJUzubv--Lp2uPIHojx{k*Je@B}j^S4F*aq?3d}J?oPs~M)i=BXz>=$sc`kR z6JBNNKY|eu&vFE#gAsHSPBm(-IfAp`>N}6T^pOEGxL(1LVGIgp8X2a37JpM6I(GpPMfUbQ6x zC-zgX>koblR&Mo61~a?AREcTVu;!z=yLHCC(-fKKb7Ji6_`wElvc-MPci`O8x(@o}@d|uHh0oU=Pf6iD zzFIWHI!_UTU~-^yNmipe_XV5)nEn?;qlrlR3!=-32ur)T$)$n_%a|HTW-?2rt;%vS zxA!pBNdkoDPLTh-7~H-;BTHZKdublUS`_=x+(>Qxs*ADM*SZe(#61SuSqSgD5e~wR zNe(`ZEl?=#)^eZ>(`KktJz=Udea_U0Flger2MI~l_8E7NpEh-3Ivhw71@qzgcueV8 z>nX)E;SEwzp)B#-<~b^4@{!p>u4k7|$=U%O-|_UVblg7cbTpQO-9TM70T*?JkD z$c&LQQ-0n@D@ssZgq@CC@|}O+WSxLcT0QF?$IOYD7x$E8sjIZw>6%q=y{ljrzB)^* z3un%9raKFY@RcU5PM5AR^ocVIW=nEPZBDn)Qd}fTaYa}uo<#Oh ziVj*SdQ&O<$et+0_s_>E1#R4`uYKW7Sp+Zn8(xue}b_qHvEN<d0mD)_=aQb5ZN6XC%b1F*`08h zs)VvTeui`Ey#*sRT+^L1k>l%KBD>>fO?FK$n1Keu*_}46VDfmXs}$sRNY<6eZ-yzq z+bcM~dnkXV{0E~(+EjkC+IsS`GUv2%JjW1)BaSRAk{FiC*_eA`3WUT&a zs((qYQ*Z9`8^q&v>J8fSTJ1RqPl^#8n5(C6JN7E|uXNwXrmxd|YmG09dnG<-QsaA0 zbJe;s&olV;Rfah}M2?SyInE(REX6rNJ@^E2oT@u&Bk>}1J3iWF;iA*@0z=Ku@ z$AL6B{~HTo`mx^L>n(lAl;+uhY!_l=uD}(D_8Wxz?BO)Dvqbqd$jzfCwYoVv1m0}si zxD!4`DJ(n|`Zns0*_5{PS>I4ReN`06E4r6pB=-t@`xj9RygYlJXeu=tcKIi{ETx}9 z%~|KLh2*$6%+W=TBy2ZlY9CJA`+A2tZX?I8MBa&hPS?Dt*STEBWxCE(o|R^Hdxt)F z8asyCK?QzLdo}9D^Et;MB|7p~N^9|0=^BjU{T$1lS ztQt)u<^CO79-Mg`|J|Ub6IN($B1lJ{tOwE3xrY~?+*EupYG8njTU2pgSGZs{_T)dr z*n_zT0S8UJ&V&YbSue75&B1!%3e*1T@h55Y-laC;>5vcRVQ(k;{;KO@;MqX&VG9;p zMQgO}RM%B_FW1}$`+OvLdzm5)Qaf=3M{L9{7Vi2+Y^_=%9JJsN_0t+!Y{dGWz&qnX zg#b&G;@h_{%y9-e!j`TX+p`${3lX(}Wmla0{N zo=34E>>~-0?=#JZ+4~!Ep@GAkQ6>vI77;_bI_X)#na^x?nd(yzjK3Gm#l(N1TCB+5lKrWrN z!0gh3Tuw2&9H5r*8~tq3nvmW@spPm{cPygvS={g9n~LXqRrk;;l6n>2x-iEV$noEr zBWGYfxp+dzTy6b54Wymef)uOFeveZPqC-2wKTRtV3@eV;UY%o*jT(QR5z=*)KiBki zssBnQ4X(p{%S3$I3~W1nin1EhrVrsr)1+sXinEFd^F9p(hHU?T=YQuXfk4~O1A$$e zj65x>4+QA{0_cOhjQsZ4Z1}~>d)XI%O%p5ZiMU@I7XQ`AAN`xdUbQh0p#QhDf3x3T zyWqCohQ-2Pws zr~K)8Y|eb?>FCec_8m(1LVV#RjYIi!`AsLDl6L`}LAA=?U}P+UgF|^qJB=#myD`X5 zft$0d-Rq>y+#j8t^5lKksGif&*p~g$pW?q4W?}Qr+Xtx?(Mw7Kwyh6fJJ>m1!Z{_+ zM(0=xeEFnuNwKCx({MQ8>f3KD6dV$G=xmK3&;rRY=%M0pz|rpj^gxJ8?4~f4rUz2- z2+0uYtn%$?dGbtXfnb?JBLq*XB&Fm8bwMH&9R`vT$QCUgs3DZmu9|a@rt~qZU!MHC zLwS=5ZD+*+A1e;jAZ_0^`~($7!eVf()m0&8Swi$5{K>3qpv9@{K-_@Rkq*QYKSHK( z5;_pHqQ4~Y2P%Yda3~d2w{~wXRpxGIcdE(LjGFwyD1);LD$Xujppigaf#L2vSUsm* zdMcsoJI!4Zx(AZ3djR#kwVFbJkBp>)11>Qu1Hg0$G+R=2B>;a*ZAZaQd(GLB*lQLd z%o?2jZUBTdlOm2)&lFW`FAW^9l&(kp;;qx{_PO%mgqkv2jl=6&M+$tI{%q2;AY%=s z-yfjar+YEWmmFktr1Yai9Ph4i$i?*l2c@8>X^(UAKT{J1*Cq{wOt;T>Uy~3XOOXd2 z#xShBN(cxwxx8h>&*I!&IUU0ztD<#L&)t!cC?4V))I;Sonv=?W>meub%QFQ z>`*u6NVY7Z=|wQ@`;a!$sMXVW9p138%aPJf2E@La&h%fzJ2y1m3q-tg^ms?Z8|nN* z{~pTU#WlPqhh(tXGHwQ))sLI`PN9jc1t74*lAXJ-I8Dhn)UXJmz@@s__t?wf}~Vs(pHTj;S?!y8$i!)l>mwMy~*-8L>lnYv7T zkJkOm#P^%Je-XZkZRG8mx(BjYp=Xh|^NMS*VO7D39?VmpW1GDVHzXIhcfWc*%r~H3 zOeNpVK)`~0YfPc5)XiM*J`Y3lljuJ0Vjzmv(n1s`N93gf zdrYS&s6%o57yPMrL-pu}&{sz7gTRpb!Cx12<7}=5O?k8)iIu4@FAU+C5y%Nc)Q#%H ze@-ad&J88L0K{l%P)VdN+LU$T*CAuMD%@W&j+FOn5xPn9{<9pC_eX(^sd_#56vIdb zhLI{7Mo=e7lj>~GT$)~Mdk#77b0>8r$hi6xqWar;%U{Rcg(df32(-hr?9pW#6^X7h z$>{z?zV`?#GJgGE1{2)4hgttid~#RyBnbX0-)|&n`Tn8o@8{cM%MalN(y4y}@tK;Z zRnMbno|jV%diy;0h1O$C0<|*At!UH8yfQR>J^{L4J=CT(H{I8tNc5wzIH- zHJ&%6^bM>D(|98&9e&urnlU;3?(wsxj>i}Fg@(;cpD_N8JEuxA?F(i0)NWd+p$U@< z*@2+zfziQD7ICM8?K4!HX`fzoF^W0N`;U+>i61htw58vl3@ zj1mOT3W7(8pq>c!14Mrg2zm>G`GQ~$5o{!aO+?TY1nmXEI6*)OzO#!6UIhVdq^$R! zO-Hhff&T$`Fi%Z^n1wR@1{}nFBe%lEHx55q2<$|l9KN6ECq;LrJ6Cp+OD0j1egO-0 zfKcv&kVj17- z!kgRlz1&DvqF$(cuDg8H=lI9_6rBc+XZf+;iSnbdb@vzfXZr_fIdz`FEp9f4hHt9> zW{F2NG7oPrC%c2@31NQ|#WmjhOD%BDyIU z&oEFSjv9*NC?OCMM=$m*u3y+n^3E|XWtcSJ-lxc z?&=ee?n3pV0c&Hf4*6AqC4<)JAxOkY5rRxThT2E2IAkw+SNgQRkvbMOkwy`yn@gF5 zVo?>42oq_<80L-=4V*aIKN3GDo_w(>`IVH8(r4ifp~>H1O1=$|1B6Q+5Ima`!LKC6 z#e@T;|D11vDaK4x6?(_Yhz*A(rw&Xb8Z zVo>S{KNYBOCdG{}$)6BIy6R&Zxkf38T>biE<~Wppms(~-qjBw8_#y$Y3YA=)nMwxx zxJ1FyaMl~yW}sjbuJ zN8snglD^rL^dd?_=`%Sj>B~$>`{*5oZ&gAp5@D|~9)DB}KLP$IruZZHV+nE;n?E)q zFW`?6AZil+cwInZ;*bAAP4|TO<2?|fM`He%Vnn0y#|nzZ;E&;_ohX02i4yAk;k%zJ z>4RaR{IQUnMO##J36Lh@kE={c&k#uu4NKZ$N_r!`gFp5ZN8yjsz1ddzD=S|iMW%fA zJxC`vp^4OAN_Vx&+UPqA?3{~?EB6Jjbij=9$t5q#fIh8CsvOW~Y$DR z+RVAXMI@s3<#1u`8F!}1AHfi?l`nZxUvHJ1P+GkVm?v92v^)8JI^NX`j)G_Asay1! z`R$XYjh{UGs;e;H?j)_AS}-efdcpMD#aw)*tMK*-{~vE(0v}b8{GSMsAjbqH8c(94 z#v7C<5tWQ&a7Giv1H}UcIRxbrW;hi51v4WV-j2&ExN%o7>w4fF4={pA5KN-$5ii6W z6``Mlh^PTC^8bFT`@NY734-hX{Yd8ZU0qdOU0vN>J#3OWqZJ%IY2>gG*CB+%bKS(& zLb66b(^oQPbk9|%-9i5WS&gf~49_C%;ZmG4@PuE)C)Dn|t+FJkQSaOg-vfAS2R+LhRQcUYnQ?M(%@g*96{%>e} za26K3!R#UoUUBV3s49_AWR1@97JTCMobw5;-%bjYt@;hWlSiY4SHCkYoQW3VqYx8x zVva+MeGw#i4_(bhOj6 z)e@%VVx#JH3N6&(?s-5Qt+GAApNzlfuQW(*RP(@KNv!7sH|Y2AuJR7iZ{%SOk|!L7*>+dojr5(CvnwfwhqA)_b!DPxJ} zo5(5+3>gui(LbEb0rdBsM)Z$Ley`DcnfFrXy^K7pOsWFW*8|aawb+K9*E@ij$3kf+ z!Lge&dHfDSd#g&j2rEuV3Jj3qHaF+47>#(jDc7sGvO71@Hkgd`S&IvfLZH zaQeck(gO7U!Vf&diH1T|g>z2x*Y%S$zjao+pA%nQmOt93ykC}_g0^PX`J*@I_@n*0 z_@n3NLVu`XdHmM#H+peiUB46fRaic`$Edn~J(<>TC}Z$D*!&JOzkc&uXnuRkZxlvZJnDU|{?#e@g{9T#_U?`wyn7a(1^VKhRNlZVS>!EyQHD_P zWR9J)9)_9K_+JiKFLF?sXBu~?87n!AynPnx@dIFUwF7HkK!Wse9KZ3AImBe&0|c5a{$_SQK^dfscU>N`Y?N7efp% z&DRE6eff?O%X#h&d;>Hu0z$J?PrMvsKuYD!a=deCf5!KWM2a`5ZQC5)e1)-;;?D-b zo68tVk>U#wP2QY7Nl&89*6U@PM(@Oo*@hX*R*z2NL~voDbjh081Kj9xA3B4#`y37o zPT=c^hReWxx#YuS4of_nNY3hp3vP)w+V+&QuAq7YgIFuvm9M#LNK@w)-h17lPF=pI z{FROpE%H|-keuMJ4_|Py?H+$U;^t4VEreo|3Zzt9=4NwPj8j{0@)`#&a1P;2ZVG{$ z1|h8kl7Y`!mgK2+Lt5dilTfLCF41t-f*&2u`qkmAE5JH7&-SKrRzF0Ov${>(rGD@~ zoPTDeaL=DP{~U{p=dH{?zb^f+=AW5Ywle?Rk9t$)pZ#!cfC{%K?9M+8Ky?fA&+~{T zCFYOc)%RL}dTwTwds!tejWx7L6x~VO+w4eOe#pbp9eXvq)j}ulOuj-r@ zKMfzR;Dc*}<7AE9oh$6%VOHUp+7@K0uH3#C zv_iaaKC;^Ehw5eS&#Kp1+!4%}vkc|H(wLA&fUjd2!z6-wNB)EGSNIy_6^sqW`;)CG zPlJ=hBSs)Ze+W{4X0q}GZ47!c+Xyn`T9I4I+VOm`H9AfIYn}SWE3S4njqUi|Em2KB>89R zX=H_XGKP^&&#_L)YV;~(t%B1U)f?zFDQ+cvH{mliF{Oq_TBu=2Wvhl(byFgLqF&(m zGnJE4??s7x3CPfcT|89SEm0&K^tL6o1 zthNDq>?J#i)lFkHbJkxk%(;`jB`*+tv$ZEtlNS$|OSA^x=sdBGLl-}(1tK&1b0l(Aodle5wVdF#!jU6Nby*imTa1e`{3lEEZ;S^|yZuvq69J;e1&rv1t=B zn>K?oRV9ivn_x#mf!nD10#{m}=c0GIo6VhI+XdVW9Bd@X1`d8N%Ty(9-e!|4@tl~m zk9M=QsDQOYvi(nYaj;EI+3e6W;w%nMy#e%`y3^v|5JZ!KwvSHG6JpKtdFQktt6(2! zzFvbpqY+M^yrnDL#oFu^j2QvzUXqvBD$X_Px;h*ukP?p%S3xH3o}R8BA71D!TOnF{ ziS?wIF-{jV#$mW`p1hth^o4JZ4Qk6XoC{5UZ=ZXG!f>X7TY~5{4z$2O0|{1-eBLJM zM!;IZ%2S8SBBa{~i?Islae%A?a79kfeHo0Ue*5kipm*C&=v|Izmbm*mqIV~J;=LZS zcq{u+Jx<5^TW_3-DZj=2s7`EQr~QVbdhcq#VHk*w{f2d@|4-R(=nG-s*BeX*rJ<*H zbHAY&8J+!x?d*!K#z^mzSPe{;WhK5lDu2YLdeUBH zS5}$K8xOF-l)cIg>N~cB$DDTJkNgZEqa=1q4z~4(j6hj!VR3Y^-ml!KyeL;}9aV!i z0%fbA>*&h=;C|(|s+*>U-j9-Vpo6M}?Dd$88{lNmY);+_8~_&%xwl|eG61^32_!ph zKVGU4Dmb6RO04|hy;5<0JfjWHzmj&={_ggp;O2Ll{z%s=O?!0H>eSSxt41W6zFwNf z-s|v$yiK-;^)BY)g=WJd=G{@Y{Q}Qyyp9Igv$w;14A<+o`qLYl)>$2(YesQM(4K{8 zt3#31uPvT}xq&gf@+IlR8N!oTP@I!C1j=JDc}(lrSr_s|?t~0N(f{DEqkRU7rewY{ zC3BH=ex@ffobLu;^CDgo?Sm6D*l)?j2;0?70 zh_jI~-VPr(;ll+4%bR2%Zr>?)rV z09m}fd``k=Ydt@qiQA*tyTmSMhxiHRGYJ1EGppm&_Nhl8rP=0EWEjB0tT5~vqc_m~ z(V>vk|BHWc=-6t#Jx$t~No~^;iUUXAq_Sg^zMb^eeitC`OQ?q%JCEY~dHg#OtBpSR z7r;Mm|J(rOY6|{chHz{3IPoKqXBP50Vg61=TqXX|2-))fkTbuwd>*Lk#Ab7BOXq=N zpwLe9>sb$+v@8AV^Q%Sw8j4JRivG1?s7x?=eifDW$3?rTf4zo`j{Y?*QH{~Ro?tZz z{p%WgclEEA(L>C(GAsTx1m9Nv+b5*XivM7=nUF6bLjI)l9_J-BeT#1TvSv+pOKSQ9 zeq*FfZTO=X5%MST$8kwbU#*)y zy;;*uS0tK#o>{;j?_b^`fABDgSrWtdvA56cq0k(H9bk*WN=R*fp#!W5D@J2U>9uCl z^@TS&yBt3O>$yt&^n6==gp+&v#5^7-^HricWOZxudgjeugbO@g>z0oC;Ku*us`@f9 zc4IA_>+jPqFSswXsVCl%8FH@rC*X{G^<;_tqz~24*!$NPgZR2b1B~y@u3XJk!%!ya z@INwU4f>f^H2Tbs$st9{nk?m525H=+Hpt%q9ZLubPY=vnk-A9i7Le9_I= z6T@+}4Q%`RGE1r)IUFLCfL6y%}1pTB{N?VGdGg6%E;A(2;#JU-hW9Xt^b2~)kK0w?oz zE@)x<;d)IC4(1<}bY6iA)LLMn&Q}j)q~VPh@QxaADLEG=XC5IDZ`>uYG?rjH0rxng zcxryLy7>J}JccT_1#z0qSC5T}P{;U%`so;KQk*L&;r*`c%D$b`)a28D!h43kML4C0 z{2^Gg2UW%QnJdq*z)brv+MTPa2az4zgM8P3JDh%es6Ow-*OsJ)1Kk>On$bJ8zR{`m zc~D;xLk#^t=wi{Ay=5~y?(2y>jqc-f2K)@_6^Zx<0S>8@FFuQ_kdfuq#aM(sP)IV; zZSD?r$Z(n8AT%ajNbhmLMRBnTY9>yX2a_RYt zm*}2*B6k3e#t56hbqwA&YLq+M>A|jkOKyNGKd9sAdl-+;@x+TK%!5-1y^E285C@0| z>CNi$#e9kbp0^Ms@IOu%#XPt}y><@s5&q~KWZtjU(n1&Fvt5YK0@GKkH;GOIT6iQo zsvTRYC6d5u0rMdI*dy@A?WOeaeY7J>DOag} z0_tHZ;Y^pbqhy~8=^*Qux!3~?AYf1CpB~B4r!eL!{y8u?nvZGOKK`K}6}OVMj5&#a z=t$6w#`uMIrsRwtF($)_!Em^S=#Tej5zP#tOYKLP={~0-WP-#6jgBWHX&S*{%F$9p zm`Sia5M)uAl0~S6EbzYD?l*;{FpnpIyB1`zGu{nx$S&{G|A?5`f#3 zljB#J_+XB}@Q_p56F=0wcmn~1W3X_$B*$P!Ur2QWxf|4U$&GrPW3Y6)WRAh&lgD5y z)g`1K)RZ1lF7aNBYrmJ>!l8V5JNi8~4Er*o;pyBaa z`C}(?eyjlcI6S#^UuiCE->olfm#QPtq`7`r<9DxhLN-DswtTI#(N}?Sa6f3%=qtq+ zec+TXlX=qXl9 zHw@UXa2_hMpFloQ1Y9J)cmZyb&*=?3V-_!Y6Tduwh-*(nvw&nuILuM}iywWJR$Ttz zb|7z$#^DFSSEJ{#YRQE6D{-s!Hr85>%UYbEEL0oyJ%wtqsWr03ney=aCX0}0A`up; zjRQ3@Bsf>CMNoIL6q)Br{a{7!hj?PJob-rY_)FQ(drdkKel+@&{nR$(hf9TlI1CM| z)}1{mfbyq8xMDwk3n`@54uA^V3$YQ#GNzU>M<8a1WJk=ijG^{5+R1YtVlbIr+*`_2 zK$w-P!+OZ;W`=vgop{+yyBl~)b8m$j$zr&a3}S(Bne>eih+c|+ogG9r!!Pj=I)S_p z$`>4C7RdPOFqfhs%~TDE`jy*}K6hP%f@B1=%wr1&)XglDH)^hHhz9}wwcRJll<<1~1lT&9t>`^Mn_ z6`4@v{P;!kiTs#2k$+#4AI7NOP7@~+);P}XpbYw(DJ8qWZYBH=%rQc^phmq-M1t&3 z6jO3J^RFv^(fO~zIwNwZDNuKA78wS=!o3Q*3-xKdZf&7a0WACQ;kQJ6k9Xw2Uwk1Fg+-T7#FtuezT19<+y0=r7^~&2wH(Wz@gErq zo{c@5>|Cs?z?4<081)K3;R&qQnpq*Vb07(lwmooXF;;;Be4RmCsKm!_9gg(!+Jey>>}`JGyN+%KNHDC)^T_qh}V7sE5G73 zo|7|SO}_>_jPr}d>EEj0=lrat%GqW@E^PzXUXBSV8p%RwY%%5F2kZWFy70W7%4VO7}Ifv#Q;oFNbH#CLpZ zZ*1jB$>Qj^N-lYMAke079z*BuOJVz9T96JX>R8E%e<+sj*1m)RyIsR974gf@fI#8BB=g5%fl*II0 zf0?-V%j3$XSi4Zglj?0TEe^#Wm`X}XUHWP$LIuUK{!M|%7Ekyf1Om|y`~?`bO>_gq zBkJ35IsqEd>}e@oQLr|2K*2Rxp*;I> z7)watlN|ZwFWAC|tWd8!WL58p)JWI+($V8fHckdK%dhK$(22fOeE3Vn1+U^&LY6=q z?a_uOd>)$cTT=dQQJFy=j)CInm&M0^?_c>#8~=;1zo!55d!GE%A3HzYzf`zx)Tq7v z1#fv~4><&AICcw;tF=LnS}Ju*Pu2gm@fS2q-rt{I<1eW9d(K(O1vF7`A&e5|#oGQR z1c;qks!k3-qQrXr(;w@)<@{L36~!?i3z{U(fpHcFMRC+_I?gT4*aC51;I}S^;&Ig$ ziNFI~UQNO}uc0iu$Zo-j3JT=&RL+B9)g_==q+)~8ia%JG~ z55O7Cm?82#b_4X-*z)-Ajtw)atbrY)gD}=)a6G>OQHK-+|- zW+3`;$+15KR^qKNmzu?%CpXYpR&#RRdr&iSzPAfvg{-XYu10Cdu?HSrmxA5^(4lunGcJ0Q4+2^b8n!;#cSys5A5|0X>TiJ&Oyz_k`<_ zkW5e9Tm(7KTZ>;%^SmwiUFWwZlaBaz-a1@QStmf&^%F`WEQCb9?f%%6EGuLT6nq+b z#^BCi*1kr_xB+%8jt|I6;=4F1QV7fyJObxw0gjFzdh&-6dxS zP%Bdrrkwo%`BMJDs8XZ8Yt92|+VJlgEc8`WI#bSdm|a<2+AfOe0P> z80}H~%7f`BIhyLVPFYN&$|c|9>be%y5C9^`qvF&cP*Cd$ckE2D+7IiXNDc);tgMnM zh}PC@1sN&I=4W0<+5A=OpB3sgMmd`Aw}`dB*GX0CDL40ATsjribYXJtGQ`@m@rMA) zdd3s>$zGAHX*`j05U`8!$8RmCu7_p93HVW&|Jv3Ri1mj`9HHD2Z$Bjso+as6UF=JT zmHya*Qm(jQg5EEFxLz2!QCxt`Y`_}nuD`%$IIu6UOigw%)oj{3kK?dKOe}wU9x|NF z4Eo94G{WF4C+5?w3Y79K{At@Klwop=TrWA5iOIb67G91a=WD9|7rgSfg{!)~_1MY{2Rn9tJqmw=HLL0iAz48U1cq9Nc ztNh(wWzWR^ME<6wD4m@s{paDVwvU4|s!v3dH~N_;@)HA&n4u=(ZK^Bkvz*$C=hht% z!}f{ojgUG6y>xILo(F_LdXV_)a3&D%;c|(^Qn|C_C4Lb5e>%2QZ71C#niAnDx(1FF z^_e7Ss)VoC2^@~9RuVLY!dL4Aj%oF{Bxq`dFVYDVBWj)`2<0H?kYEQS6-)Z*Ofnr0 zw?k$yQ-vBX1q`S=bly@`g4kqKd=H<(_7RZR32TthJOAO?pxE#;K=0TBb|6*eowlDN z^V)VtzCO&SW!|33h-Na6J$Gf^9C5Z}#v`$S@wgos665hZLKa)VUScql0%~!A1Ir#t z6A|HGJ&*2;O;oX)Z0?Mz2sK80FZmek7aFb~Qj^&G6bJvCCz6 zw0`}}?_5+xFzl>4m-1qT-ROOynqP`c!hvXAZx0>mn+0eQvG7 zk0(5xN~Ux_iX#j)ZT(S6w}XgpE^E#z1Cwma2a6>sR$r)DhoL?hmG^c-hBeHfy`%m~ zqjFB7#y^WMPe+w{RQ~b21Q?com8c!xw%(6xko1FevY|U;ScOJUcP6Z;(Y8`B;Zme zk3xN0&(GCfTzJlmMnvtgmJ?pABpFh-+_D2tiO%Sr1sEow9K1uJC$5M*xrA4+?Xp+e zmi=^qCp-{2dLgGDzr4z)SDZMsfEA~lb~?zFgjv7`*O;f=0uI=OgJFKNxY6rO9v8dl z9iq@#^8Do>WL(9Jdn6LA`Rs?;-w=ffn-`=bw+bgVwc{d)v!GGBNDL@lT>J{+&QhMi!XG8xLWh9K8j|rmEG$J zVCx~&yl2=l!}90HQTnn(=|8WtnQmuKb^CW_QvbSuElO1d@a*ol=wXMuz!;BhiwnN< zM2o+T@BsrKAV7#FbPF@Gg`SGn{!5z(KjUN{^9 zofCBDITrMA&?0jZ;9syVP~p7lBuyBZ!>Uvp09Cqd&F-{uylI061$W)X_7hXuxEJUt zUAC5Oz|?~o$SRWqEj6C-=?Hn}cp6vAruGFGP_N+lV7CU_vjp9HC5UT6`Cr|nH?{9U zt-7Qi_ff2;xK)a6A7{V(r_~r(n5A$CX7ibH2&P>2x?v&qHmxa+l?|q16DzCAE26?jU4!29~@DqY#2x6W{t5EkM=%2Of zF=;s8(hXHUD!bN|JiC1Me}1ol2Tw@BXbEZ*l`?pw(IbQ1OPBMwL0a%&pzP`C8f9Zp zEWVE;oA0MJdi6CVyZ*tk_pUv=YcGTgrE0u`oR@KKnRp?r#Dl)WN9OWH zSikrH$IG{qMoyl96Cm^fK4|>NX%j~d$J49uJD6iUfLC&}WAgEo1R15jbm753Y{KrX zJ%Dfg84*_YQ2a1kDO$AQJqYBLo~Q#*&ZZ5;iP)PF3z8y!JPr|mL4@wluRvo9{pkS) zRBs>+=ZV;#({FY9Gm)m!3}teCYXY>}Yb&zxhdeJ_T#x}iHE4&H@; zlku+Z2y{5JuCT|&#VI{`@>uD~3j{p5Cr9d@+_PQxo>z{s&a z$N)F$6rG_f?S&X>eCrL_xz~}{URS$nYDzye_qF_E3Z*QOvJ|>XAz!ZHfCirhYF}vCc z&4>IL3i+Y#mMo(A1*0fbs%A?J^_28bX?%_pl5~%pDvp0BF_Mmh63Au`#~(x{;MC7n!qE2w;th=Xnt!HgisS2{My( z8rvt6A~a&yk1~CIf;N2A3fwkY8b)@#v&5JpN0~;^0x`e8l9cw zHc}$nsZ!|uI5Rz^GbP~qJ7fRZJeIf5?Fjz3_^AYp37LBYb`<~+jGcD09=pa49*o7i zy6CEss=`x2YoJRkpYP^e+m&geZmWPNun-75=C0DJuU%dseY^;t^>Lq!3h$xQyhMH z6VqOJ9<>@?2skJO4o`#+9>tf~C}MsI>hr#W5I61zf+FX3`vK?PTjaOZa$4R zeIYYB#9xf+P_$I_L2UAzJfF0o%eExI*4PwBNf9sO1(HGWi{lr@FOW8{Y&u?$^$oDe z@ta&@Kh}7wsgd{G-)o-ZaON0_KSoB#c{iDl+cBkoA|rU`$Ki&FDAV-9NrAI&3#L* z5I)aqIJ{{0RyT630Qpj%wrSB-;g8CP+#5WTXO`P8g*lq3>LEI5$Lf~P(!Hb(e90`5 z{ML|iPxwBzV3xS{LIk{JJ30pU#^1d{SFmott9)ni@M!QnzW(Kf6XUk14yXR{0Op{% z&H?D`?(@w`3~qy2w|ets(~>9roQPJvkhY&eAh{+2mZ)hCm)$HMJk){9yv@a>H&&+V z^TV(j>mnB(oTxVtl{7zva-qdSfty$3jScvz?5A|kY)YTfnG4}3{TY1iIokP+2J5m9v(o^LG5(WXbVMeOcXsex#-CV$V+HE z8HGBoo2TpWNgernnJQ0fp~}M&Req3M<$Dt7mxak12mXZV#e%G|QAtsGADrp}N0qF= z0WO#s`lS~~Cj)W56~GD#=*Lx(s6Q3x24IU8XuuvjWM{n0iyOQICptKZPe|dY87P%h z=aIV3d1G{)gH4@=bJerk_co@D*6KR}CG2+SXi6*lr?#?OS+6>);yG-55+;Yp;4ps)b^+1B-zV@?D8G`;019Y_6SK#oKH>RNh9+i~)fOgo) zjHz~5e1>T&bZPv?_*f?ph>vhS&yHU%uNJZ8P|tXA{9Inj8U7^h`<)f<_J(*Lb&hTXXHt#05L?!*5N?QWkS!@LzWz^_HFdf#reW;35jr zre41+0JmT@{@C(7Xe~hbZwe^aZo#TCZ{i6fDzq>l6yk6g^MLczhXR1$n-?&B0soyb@+Uw+y9FU4yhIM?{2>Zg^lupm_AjMh0driK_9d!B@f`YmA_>pZ8hRy zj$KmKIg*9gQ$YzXInUP=M&Zv>to&n8gH z$2w(>5PS34WBKEI4P>T4c=>+xyx5Q)?CZB?u2WZ|Tk&22txpAvdWBz6x4gA`clOry zZ#QX_x2}K2*pc{~K6%)?&#r|{2-GG8>LyHC#G)A0%hcISS{I=mkxw%i~ek5KoM z9WbQNMx#=jj0>Hyzezhn(vt5JIOE-Uzft=iHU1^BL%W=Nq2RJ-0jrrv>LJVE)S&@C zW+Gu8Zm9l^#KT#BkOXhx)gu-YN&ds=t?@0%qQVnGy>W4mhB zLI%ZW6>JI`Ug>qCOln&86EwAvbdD`2;Obz0TlqhHP6ig)FLl4LuVi5@Y6`m?Rlo0U zQZT*irpG2VUCB1A{OQe__9iv`3%|i62X-No;Cz5Xf6DvO0X~bhBMJ}b39l*pggWr3 z!0P+g~qX)j(0BJj4|XX=eCR=>($_DfUnGAvbaOea*$qz?ko zEvgWWA`)DM^<&*ipaPQtY}Z@V(MSo*sw?>YBvXjcUY@oX| z!0SP+*-vI|;$E?j@4di_JiIzD7iTHZF6Rcv`@-vkV@jVdMGlZLbr-W zI5Stf>u;C2PpAty@r+8`)PSFIaAO?KW#}?-5n3zudRs~4`=SQ$g-7?L!N_~7fl_EKT zLoZkqa7}!f{*_X;tK%EhW1V!L{pK>ddnseIj5%?p)aoUH{LMHEjk<;+FLdupRqWPQ zf>pY?Suv;zT(PK?O7tW0;-f~Obg$9RiA+PSz%Nf-V1YBJl;><9ai=3%kKIM;i;fQT z@U!Q(SC95;T4@h1z})NUsqeybS#byI(`3+>(g}iD0MdBviToRwZj@_;2+)4s81d^o zJVA={tTW2CV;#8~0lG(xd({XZdicR8r1#3aibsy4e3kiF#p}oSb`WH0(g+ITHP!eNgKrSCc58}Q$Olj zNzibI`GbVP_)!5QIDLqm$%I&bwgKWs0FeTEhDjK#6G{PJ8f;>*{O=>Wvwf2j+RgFh z!fZ&73LlyDZb(P)uAw@67J~60mr-K-(O$DKKx*J^B!^jH`7u6HAgoHNjE|JknfIgx zFG4*HsFvAP-9DW#7xX}Dn1u3QbE2yd4bN(j^XFy-ti1ykU94Pyf9>?@ii0R=bwwFQ z_jtEBxKAq0hZ#F%j-$4?%^g8)#7gCnN}L;7?BG|9mDDZ|E&k*)vQ!n`!^ zv+0-vYpB*e*PckqSp5O@38Uq&$1Hz5BdqNE*J>SdHJ}mCN|8hM=)S5128IK!bKFPSnl$c&lLSa-bK$|CZJ zI+^-Spwbixz8>$$YBY-nSAdtx)ssv|O~EB*%EITP!sYX&q;PrgK2uVM<~jU6NwNsP z!z)vNsa!(AGaSyp09n9b>}Tktc!6{SP4r+Bcz;s&DtI`84e|ZsqPghYVt=U=`%4Gb zfyr}YJI>BK*cXt~8F&(-|skNyIReF4gty$9GlISoRU)wWMRZN7A+EMmqN zsex~WfhZoj!0+5f+Kksz)wdu2)-*?UZ~!$-LZMO|PNeiQLX#_GV={jN;F--HnY&8W zMPQu7-1Q*Z6CU8|eNG$HhjW>@DJ$nPQ+=Z>yaYoIJsyNAi=x|8r{GSUf}g7pWiZ|b zKpKc0E2BDi4NQ!?2lLN+H-~v)CQhym$-&$TBZ2qMOgI^=MFZ=w@8dLpiBfH72f!8= zqxU-JR1f!WWSM{+n~o?!!G~Fe1=T7vQxtuGR}+e&%MZbix2*PiY%h{xR^bdDev1|2 zn}?#xw(sqky$say$2x5}13$yt&hn?%H?2edT;wU6))m(U9w4bqSDj#{*y= zt=kc>2csRf$wh8VZz$i4DDIkhX73}==5Iy8RIW>Ux~|b_n|IUVjv*p5Ud#(CAIhisf&fnW#FgH#Iqu69eg= zos)ClhmZlvzEJbzXyg+e#dSRd5LpT;@aQxjRSO8A;MzwbN@8hID+WN0?ayJlL4OzMqP8Puz0QjUZ z2`3wyIvPH?RpVsv47caN3A3u>$rNyTR_vyzn^5cz;^a67CtJ~1`w(fB7MsN)|1M+2 zvFuxMI2>AgC5F!7iKglk;tvx7){=GFGa-IuOW1K(7|ZW0uwu3I){c&eiSw^!;w&%5 z##r-0rY?89zXZq<(%}_>dYAk>2TlFgwEG0TZIPchiD_$jUJ~t&M}vBd)3*vJbdO-o znZ=n^O%QzM?>H|(yBB}^!?fFJO4{Xh2P-w z&_4|4n<;SeRO;`{L2G_a8nflFAN&<6NsIGxxtW*$%3nFr5cvf4a}VDW*}$&|1(-JK zmvZRs3t}Zt*WTyS%VrKt^UPm`69pi(J5~Kd0$h!x1@ZLIw^nGNir@f!G{U&}K6UcT zc8$hi@~p&^3-^5O;SdgK5SPvyqd3?zP__Axs#5mT6Es#KN#Fm;rAnzQNq58Nq+X3V z_OZpXtqKp0rP>#Vu0U%#YBZX#c?6fxENxGaam=V>pgL+qdqUGa0Zrh456y?$J2qR> z-U50jS>q=l_)L1~%q$%Gx))lo-GA@jWto4YQdi9HDa)*ds-juubAClAH#N(QCd+&V zoCwR<6GYPPa=tm}zX4>X3&?E(2n8b;nNE=H&G_>><7VNu{{jhIEomh5mbNMEG!h09 z38b2+FZT7n4@mZZ1IWAJPYuW?{EAST0SR9qVB7eEsjgm~PbT6h4f+(KzjWM9PE2kNAH^(~;+b>HOV{+Lk_AxCgD>`=K# zh+iR)taNkNJGq~b+=4()WEo;@zJVmU?{sq?$(02mDV5yPOSy*98+p|Yh)mWvumX3) zROE6vekq&jcjS&IJR1~o<&%N1%z+rC%*jkR-RBLr_aC zvZ+0{wQ=IwP5kakbp7`PA3px0B3v-er;$Ch6GVh)1QUP(BFK2? z7c+{?#)ERyF(1enJ9V6(jjOC>sA-QiwqJ0TiZoF-Buf9;V}ko*`=WY-a8INP-O&2i z^YTUg>m_{IGevz~UJjv_+}A#9+nH4oZx#XNQ>53>e)3?D0cCss*WsMbE%3GGF;k)yEZf=a?D-?C#ex76rdRqA6zxwPY<__CX4 zV8^f#J#+R{qjwnEoO3)~E+>gR00hhj0CxC1Z2+R&anORLE^%%ER8(M8e`etj1iQVV-$rFZS1D07C>IxN0Uq)l_Dp)#LpZY(Ny3?fB#K&(KH5LC z3MZ2(+s-rz!KV(b>~aoSh!K+T`#=uOEA6FPTc0Xk>I zeOti8*)aHjz@mGL0~=ZgyvD(wf6a9U5g*0(6cHp#>JV%54v+em^Xvf5F$0DWhRvY4 zb|nK^NG5Hmja<5WyLP50g#geQ{^742K3s?XdCQjH17jXg`Z1z`y`uK(JmDK)xy1VU znRH)deXtWyR)o`n-+d08t+GPBBk=Po`#^jr?_2c&;=R$jqTF9fe?dJ9Wiu}Ss!=>p zuu-k}8jV;HHUi}$aZJ$HbG=+z8Hr|jS|h?|hNPuNH5)aCYlkOm}&I>elZ|+ z_V=~wROc%N+o!Dd%Ott!0O5>z9HjuG~tjjay+o2M@BFC!p(^YZiSg~11E0@+J?J}oN+c#f%o8%cvz#G85G(R zkiq@UAyU~c#8hAiz_Z||VhH)@exK%KUl=#>e*-FgJsX`#GLi}MB@Ywshp%`}Cds^! zdYnLFuTpzHQu3?vrF^xToGAUjLh=4+!bS0OFi&WKR3l%M&u`$%W>E08L!BR#U2g{u z;q63ql5L21cy5W{;m2OOAJqRgx_J0s^`sb0n4Xvu23y!SnRnU)ewkiAL6jvIOJv-q zNxU45u)H%!_|4F5LGMr|Xl)+=rjTxLP?t>R5cPzA)}z*1oQFZA&PFVb0N5K5+w-GT zcG#+_77H4>40qY#*$og5a5%lEw#$X58jcu-3jSBCLuVF16D~*a&X(qgdGh66z@H}s zbw(I47kM4C5{FFW9t=g7J^qRS@j4s7W!v!-$|^|Sf}teEW@;%QPXhzt@LjMM{51v- zf`kwCMK6wHFO16n)Ou)mXCX2tDe@jh<{@(Lq{!Kf!0qTq|Q! z9{{MYfgYsXBX3PDXNoFdX5q5fI+2B$d??Bv6?bFU6mDQ-Yuj7mF2b37i=tnsjZbs- zRVX75o(x2zMV1^`v4;3%DJfFGn!g2E%u>?Er%V<4*!dG*x&YO)ZRgnJ{2GR$v1QTq^@>r+5^ARX#m;jku_h&?!M9~CYa@L7Cv!)DHA`Y59#>S(_Ojx<_o6- zCA+VCZ#bE7Ua(6;}{5CCc5`fbKNU6MwIYSquhqWJ6nxHHH-_o?r0Q; zsR-O90Wt~#_ep?^gaN?QboK*?!C0wRPXg7fKUj%im8xXW+$;M##wHP_EXe~6-9nxU zHAC`{Q0c*2k%z=q*GVM#2Te>tDI}0%)Bs5!Ga})7oj`t7`I4X^3}3AiGMR9QBnY&@ zOVJ|UKSE6WeEDoLSn-4lF=7!_uQo}PE4DsCFd_dVY4DW@AN~W;K!Tz5Gf!;78QPJL zg8LbX7TSli!?6$q@t&p2`yvxi_&E^fNW93q2r$o;%rgSh2abyEKh7K#OYEUQt)Ba2 zJ4e!nI$-~cP2#2iT;TgkYe9lKv7MnhM+RUb4X;CQFGa1~#aS_Sr)s%1)B6w9djjf3 zyEw$m_c`SZ3HHEa#&}1_oI`V-Fx|X3hCRymtz1UC$JHSJJYl|bDq8LuotBFVa5Sxr z=hijgFbs)mBfPLEP&u>P;f&%B5Mf1nyi}{{pC#=jJ_Jd|`|6duy00$S11&nCeixVK zg<}1%nkRA@psG(utz=V~Cb6`oA( zi{Ow}n6)p6!10E)?ROGYrAQY&gKg1K73x4nnT26^qr}SF1S$;)?jo`KX4Je!Qd{Sy z)6l8%1;Xl^GYiFDUJ153S=-?#heLRhR?&bRU`QK14 zg+&I11s9$W7WQaoR99kjKu#>$k3%N=!DIDg0x2*S#r8~z+_fnuE46#i0pB9`X>YDl zix9MijD{4v7@&6p7^K{qj{rlG;txPq;P~9G@%Ru5CE;-ZYEGO1ei^6)3SgP;0Txs@ z8jl!HAR0%5L&V#BJn6y4FV~F|LDu|3nERbqz_qdLS;zpWXmdW7dG<)t-ZhfqAEv;5 zhv3YeS;`Rf)J^a5F|b%kWDQxA{(zRCWpQ;s`lnC2cu*nZmN zn2j8Q0F!t-6X%=6>m{*HU2A@?Fuxa>-}B^GE&+PNPm;*go1O(dWh#>AFy(18wjj%{ zr=3iHbu>D4Q-s-Au-zQ@y(0&GZ;E-I$z-n{?8g&&@;#Y;OI!H7#>8<+_;&fz87N zl8F;0{cfP9D)r0SB$^Wldn()zx%pN*`QDLyhTv?%z92c@t4_X0C7+@8O6EHzIbVa5 zuT1h8Qr9tG6OYspXN2!lC*PHl&(K+%h`ev|8Ac7)F>EdG4OUPm>RL6;pF@KEqLW*L z9===W9?0BH?g_Xm9o^hObapmHa{!7#@C=nctGkiO9u_ ze4$xnB_khd7HKi^4*nU`EagTX~;y5W#la;l7lNkSD^N4SdWEu7&C@3Pn#GA!bcI_De^8x zE^u<{Cc-jIxKR51J#t4m$bw35#o)1rNY*-a?ifvrzVfR_d4wKH?SoBa0@_r@v}YUX z{PQb<$wF=Lo<82?-)X?1E09!{_?Fd3a?(pQ{ee&FPjgzQgY zVzal<&PK6C-doFTADe6v^AYoOH?>i;Mfggty{}Whfwu#~J4H4Uz~Ar(^+P!xh=Czj z{3P@KPMvJ`6z25moO&8MgE72HVuww%?uxkNEmdvbA$>rFeQkNTfE}RSuM1%(F}{48 z8CZ8)!YhZ1onCI`U})r@yyPZ%P|YrIV!#-9uEE{toMzMKr|?F(R1JpMpnWPiW3(Ni z?d(8n5VMu|`^mvE3h9l`BB=xL=ffY<5rU-ePSAzzdOJ4|Z~!vAKj3+RN-P*~R2MhB;4ia+=6} z8F`?I6nxKP*$PuuIA%U$)=@Gf)%F2pf{9FK4jvA+e`=QbF-FpjUvdrN@O7aRDUi!s z@ug}*gC@S~qQqUvy(TG~p$D=c2lVrda{Abh4awbkG7G5xv3-owg6VNCvpA9Hap)q+ zILfif%@j_IMA2zum-9sKkbt&`MHWh+L5s#mBw%cF2aV8@V3f8Ldcxz833=-|YdN}SjU8jBnZ@@>+G+D`|y6pwOTWfW(iMxwq0vD(`mO6#pAaL8BK$H zL@XYY7}FA8hKkRV7-JGFV=dP5Ot#%#+BS?jnHY=k51gfdkC~55rn%t&V5?NEeZz3W zzV?+Sos1eDzyOus=a|9a059wDJM|cvpTI~ty5LqGI??7M2xu*tdwVcrAE&eiQe3bS z5<7k80(2Q;?_&xGSbs;1fR!s?nU2n3zI*T|K9wCrPT}=>_4DiO9XPc^e5j;A#$1N- zRcakmG$uj=;=|)-3ug3+baH%VQfOoxx4@J75gHr6DK+BCI9x0>!)vM3FBrm&XZU4v zM1`CNm4)jN$)Xpo9YH`@xcU*9z!~=wWNMJ>%_lGotIo{-zugF~jGdAWt?WiL`qrig_Xj?env1I9c)0j8e{_xd?NtK0)?cAs~njE zWp!D&CAb##!|vPzrCAX^xmRL7a}%FA=Cdx+8(%m90c3uwHVSTK!v}^L`ZhW=n?8y* z;z$!~R&NYqP=n%tA#FB_OFn%{n=Ptd?2hiJ8coz%`Cg(yyDTCaRC`8iB&k*SE{?8) z%OWB$$%X=V!11&BXCVIUUenL(dIjKbUXiA2D^i=jozbRgzcjs3jjAVU9e+jMOD^`$ z+B6r4@kZBx6N})#&AP?)6@w#pd>oLM)nEN|2R0vuW(CTAZR45!0%KztywG~y@Q#)K z^p#DYo9p{*$cAS(2o|J`h4 zYW(CqD=@vbA8z?!e9T%+q>w^Mp6o^dpMhwdKQ^qrMV zY_irJri0*&ucW?}af&g%t)G;ySH~wx*Ca|;qjXg(rJtdHiz-?g->+rM8SC#N2hgz9 z4jcVeelf#V_RI5W*J@HEk(OXM6Omq@rV4i$ZK$2MW>H(>nz0w;k zj{K2rT|`o3wgMo!H$m4Way8)A1fMrfHG?YA!-`fbm|03(&j)Vi_)3k5elAS(<;Fxm zOK*KvsI4#m0px#mjzRttiPC$F{41nv#&y7QGV5XhsYm|F7Qo}+Go-mef5~g z#nAKt*v!P0B92Oy{ca+z0&(O-`%O1aPOKyPRz|;?h#m+sK#hK#(H_uPY7KwniR_Jl z-QJ1OZLeUix7@-$v=d>_rmY7howP<@ReI=HmZ4X#Qt|3lL4R8sicpF3#K+|}H`DxZ zGOD_P$}ACl1HrW_OM<28L3;I?tI{P{q5W+w5~`WXg3n;8okp?x2@vW$=y5J0haxgw z0I&ocEPMgZ0gV6}>yTrl%|}^+ZQ9c2JrYDCoYxkq7=q!C`2IQkSm2ve>X20=2Yk2r zabn_A{F{M)kK>;^KVRm(RL^&1n{wbs>oso_|F7{z#WP9l=1khS($wJ#xNWm701uqS zZEnt8k;BM5Gy=uKaa3YuOukd|hCd2#A2)O?iVn}Re6L0Ob;YSTdU9)6%E}1eclq>} z3ioctO^!d(6vX3m?V1K=7DXrHRm{~nNfU>tJ1u7BJU;y;(?>_%Q{(6zh&IA2S#;3) zR-BE|Us%!{5E>-%9}|r=t)up!bxW@L2ee&?Iyhwa=fM?BEdMPJM^dK`c$7ajvmTzi z)~k_NbLjU_=(-vXLuteK0H4;N^~_X^k^RS5e{+4!Z>a4xx8pgiF&t=FtKA30yaGJj%O`&=Gpv4pF4_^ctWP z&aAnb#>7>KU3IF|JnYbk6f}M~;EEKnIDvB3QGcZm((9n7Kft2U#tWg1>oVV}VL$== zSg%9<#*ejB{Ckc^p}l9KdJqLZNU2q4;fp=(OV-xDpfPf(r-v|$!IvKfzpuf9(9wRP zR{$fFcAi9j3?b(CF+T=WY%w8GjR6J)bQf&te4{|1^?I%u)K%yTs+Ur8S-q7%CPoP^ zu1MK;)sxZY_3${p>CbZ3Y9c;WJj?nuJ`j>=_nQ7(*DFnD>!vsVCAH}#%M(pcWEOP( z_7}9M4-=2BKT>!83PgVhM1Kp^`G{PIR-cGg{4yxlvRpq3;Zl&NrvA8=nDG!(U@Jh?)1(gT3?tj44_1p73ys)y9S` zWQDcpF*MbZ=uAYtkzNuFAvgqg$vz4#j^kkvutZa>Y|6u5q`i#PP|apauKeyqia7O! z=e0CQWH{x@QWJ?yV6a#cA%cn$_~YtGL`n3QXlQ-uvfh}$(n2`%cyn*a{`Knq%pFaQ zh5oEiSDcLC;%U}uW;e1C6O(r6dg9A%(!5L3@ifUth+|_NR%5b?$&1*0LGp#~FiFkt z1=h2~MJ}^YPseceT8`!*p0n`cM?Eoka*F@aVyjPMzbu(!Zq8K;!3(V6F8mfpe<_JH zg}4a-Pa(#!4pfQ^HI2Do-l2j4LmeE+jglDc^-Ho0(h*#UBNy)e@*^t#o>T$S?DmL& zm;#vpnA0Mdc^aRo@a+Jm316cSszvxh#~aW>J)r*$)&PVG@NIwzolU-|c%B4RkF!G4 z6|A<)jY$H-HZ?$Ma^@dLU*h^0HX69|Em-3TuLni=-b)AX z3Y>LGEBm=kaIgt?m2lgjzidYvre{lduV8Nz-ruC>mF;NDbh>ga`+2Wm4#If$4i$Sv zb3~o`)>pt`{9A^>-b3y{6z)Z zXLc%%4bODE)4dTWJF`3P_aBay;@N?iRE}~cnwGp3xqwNHU)m9F-liRb^%$B20CoHe zat+3!vTgT(b$boLvfA^xRIFws7_gY~q5uqT9)Cf4TA=B+24q}Oh{EbXRO;7G9`DF< zojgw96P%Ne@JIb8`=1{({<;$S z&=8kHEzKWV2737<6g*r1hNDng4qoYxE$4Izg#iwvi=v;aOHR(f1ihG%7^+kZC|$Z> zz1~e_>Xs<8w;(Z>iAlPF2%PoLQFW@#3gtADr&oE0XiJROnu@20Ajww<7 zu;Ln|+1z>1BKGu_p*#v}*i`ryvQEHv7k*oTFLY7@w9u*eHV}o*#CLBEUC2wO$$wTv z?0Fi_X$J7uA!SQdzK(Qyvs!i65vBt8CpA6kD3EMZ>KRrxD&hYV@^#iGBCRO8DnN(X z??cvt;p1WQH+tb)>!*A29cudRcxIf}8GOWZ4e`w9yK=mJg5A3YuL^$@8eHqEIKf|i z(S)fb!!Z0%_91`uq+tI^6UJSH(dGM>zk2e-Dg8L~5W2h8_avuaF-)Dd80Mu2KcUwg z<+m0~KP|Cv#Sh2o_7u6bfZd5Z&;$E6h)eOeJO(8k`_m+(Xyc!D4DHyr#E~S-WP+u- zLQ%k)OV?QbR(*GXnbZ-9n*7AKTa(OQ(U_pO<(i0+uKpNkGaPi=mBmb`td>8GTsZ(6 zdkH0P;+H3w>x*INZ4RPoPb@H*aKa6u#XV5OYp_&z6^odxsBc51GW|^;`zh2~ zT^t=r$yra*;g=RID1EScMI!tX8$ANIOMr+#fX@pV^N>f*c+u)(tUAvTO|k6ro8U}7 zmT@?KAn38k2fO^FmV!h{3s*}}nlbNI%~pMUYeQ4C#!lvQ?YvMT=BjIu*MTNHNeG}- zp8k@cAv4~k^;@$iN&?vjb~!$HY6h3;$^^ z`(*BTx7X!Ffz#FbZ0UfVG8qdQ@oSRDGUxl5a29Q2T2aVD&DnC z4hDTXM~&M4l$KKOJ}ELGMW1!`uR(f;A`jHW`%Ho88(34+U>Y(@+B~T&W61x3tiSg@ z(-~|}_?BBw)hLN2?NJw%Vzs*K_nD$VGS;=3%=zEG&xBXh18`Tb%|`)`Z)z4yNBF%g z6QZb^>&n0VjIP3rK%>`LK%$8^ulYhHheRDxWb0Dfbab-iXqd@570d5k5otYW`B zgVx5~eVxe%OrSm~IUQufviPD~ICaXhSinDs(fZ*mMaqg0n6;V&Y_={w2TUU`fbD+! zFYC&s{hywY_TQeF+WtQnZQ8$t*@1>hj~fni^<&{L*?$F#|DwL>4Ig6FJp7Rc*;2MT zOZG;~mNn2W7u-CjY#lzZCZ6VcE%~rG_6#FSmtBFAGikx&up4$ZuN6Q?hD=G#ylwbcWc?nSro znSnn2vpi+m!44i1pb~3gd2bEEMI7GO%WS3>2g>?q=EUzTTju9_*>5fDjRuPG&_OX? zuEz+j4xWTt=f$!7CAim5d;3ysBqBqjx^o-&yQ$6;De5CNOj<`jGJ#mIdt%@OyPJ`7 zN%u@O1f_KU&>3k9t6dJDU%?GBA;?o$r@7fo{oXk~4E|7}){v=mP^N0{W=_Mr~g3iJ|V^XU9cMI7tN}AL;DcNSY*;-_WAxO4| zx$MxSUOUlYhw~kFh=ShsSv#@ABt(-P1}xI-(8~Hx=HFNvB#$pzD~|(X3YOcEMbXd; z(Kp=(=x%*`2bL=@d&Sk$%5}L#(eM22S3>>Wf~Etp6?qh6vBeCjHO1Id>H)cfM~)T< zHv^DIAEp4$xZ-F>nC73u&se8^_<>A~{6;-*&J=d-vRfWcawPAdHct>t3E) zUqs#b%)#d~1R1x&k4hA{4F!6Bg!C-PyNvhVCgJkm;g6?ii)Y>{Ju6f?O4m|Od;ViT z^l$qp+K^UL?yJOUr+-m;rGs9zMTb797kF~^t5*JE72+#JsWdz#3}exVk)v`!EMEPq zjZDX1ECEAU?#Mfx>c)q-;;F<6ZUm+#EI&#X#jh0{Y*vr1f&~_R;ycp#?U)rjDz_eQ zR=9k}O^@3y{taX=0v?QhBoP;pdqxrH-O;Zn>|qOG)*KF*P>cZNqpdhV5NtymZQ(tH_9Uh>7mKE^u&1W zg^@+RVz*=Y8)6*de1LU+7Ne^WjV3`@oDjrzIrNVBMSjk4&mzUt9=s20n9uBcfd#{*zJ&}P@4WrS(U}*}cOt~#zrEWrP5Ox8p9XPG>|55iY@KG06|9`^G zAm9cSjn+%FScBJqQc10vg)Ho90+EYiD+Uyhv3c2ZMFDot@u2) zrhTdguR-hvZL9HC@lwUs%Xhoh;tj!D{_oGse0MkDQu;jp{{PpX7uh-AGiPSb%$)Dc znVIuFqa8(5#24))?a7)4TnS*S*=MY|aZmwBU6W=t0wHawvsM@dAF{uDe_l2S)&?Fg z4ii-)Sz2&DR-HJR6~VB5lVbaB$uqMTBVVid;;a5`3^y92lE!6$_gB6zur0!okZUs5 zY&4mxM}MZItr*U_di>UOmN~z4(-;mAHCJc@^B8|Ww>o)J-uciqO2brpIbn6;eKdca z51G?WCZ+6@VsXLx@>?d<&@b2NvJ$-E64Mpc82M zsVoBA(9mKM$h^GGU@7b}Lu&=E<$6n7OR?Te6Jdmq3uK5$U&Bu@b-l4b$TG9mX4K@B znY_i!PelAPe%QCQLND7W<4ji=XR_V$S0TU8k0BFNf6m9)Q8LgX6R&ieBeNr>^Yti? zfhI#I8Vx+BuXRW*2I8j+Q`?7(Q*di??%0b?Gfli;jhfgr8p^zDuxUbSEVUnWR2dpO zmX3wSG}MU(X&MUaa@8tV%h)|i9eczd^Z($+e4N-oM-JoE)c^Qdu6N`Asrt&RrE8Yx zhD@``&=&hp=6dsFM~5pi_nRlv0MmG zy?Bwt*(#fPZ|TVSZN2yJU%AD;pMNII?ceX@{fwPRZQQFFJ_}DC1saO7&_JDv-mIaqIa_zN&7ok zGCblv|E35{y&?!U+Aezm9m#UcOKgEupxLDua$%sbp)W}f5^ zy+=~l^ig{1wd*hhvDsUHhR|*!|Zx|{kLSh6w@~bO3qGhWp(0L zHeHW*+mC681G~&RQ@Z``H>;?S%J=SgUGia0 zNlIC&lvF2c=n^?dP7Fn1Fhr=<*gDPVB)+4XU0UzaGyAC-Q6$8kchphlLj}_ueqBtf zY&8?2)vU#~m!y7VYEnH+AFy+~dO>#Q)G#z#XxrM}!6G+i@amcTH zn{nqw7v~jSWs5$vPtk9z&K3PLksv7#{%Du`Q_J6$nN=|HL?rQ?+2!<2+wNAr=G3rT zujc_@9>BocRh4+3n^ZX(UTt?NmX0j-URuxDa3Zetbyr+x!u-27+}bLTq^t(DY+m)d z{)nYlJuGhCj>*QMc!yviIg?42^`SeNY(nfbQx~j=pFu`iZg;?`J#}vW zc>lol7vS!oqu@IS76g9Y9cZrQi6)t7`IQiq3B%C*w^SILJA#0gE7gLpR^6pxYI3NoXq`z(Yp(~gS6(vGV zk=CUnWf#@t-S9W8Y?CWwFBVQVbt)LOF}!|T|L}dcpYmY3X3>Nwnq-KVXRdF+$7q)RrRX3Q3+!B)b?JiAGnEm~e7S{-yzW4K%CKX_Ko8sCniR9Q$erp|3PbNT^Z<(JRZiq#5UD5dxEO zF@X2q)NrMlLp9cHH`>$PrNl7SXqHaD2g)?fcKEPH7wz6>H~Q_;YH6`}Gae+Bgk5K4 zz3W%v&{xe~f+_!3xtzp%_O&tt9XZ*0?c(J!x_K4)$3JN4m1YS|^RNUk9~4r9Zg_U? z8Xxo7w?;mv=E`m8Rjz&A{>3HZ$G&1}Fq@QKrj1?imE#x~&>`@V=G@V_9VqE3w1nO; z-gx~I*y@-Mdt}qm2GAjI5nXkZFG#OfhI)Vqb&~i#yfhe1tHBva8i|}@3@84^D z;#Sij`gX_&Lt$)^za*Kq)reAItj^e#EJ~kl`rYpCJWtEGr22Nqe1YjbVvy>L!st4! za#VBmoxdpg6-bGKx7r{jw1v@IK}t})W+C|+Bhd1!c@LL$rc(gRKR(k85@yC@uZXw9 zej;}n^sL>?FoerNH@#cCzX`-?gyh`d5^DO!=lAe zp0N9CEUjOHp`V_x`>R?!=ZeU}x!5An^p&O6C!{KmwC<{6O`e*Eb7jnboqe=RR)-t2yy>66j-`!=HsN^e*(_p?)+wCCPs;td;xPq}D ziLFDj=3alKtWGS`5ZP{CkFL=o6;{aRB$SzED7CtEl=m6RKuakDwxQ;F0!B@jA`oA|LwX56 zS(6#g2*)O#S3jVGp0N_a#lhrYC&(xA?6T30DD6hUj|EzOsE5|E|5+qD^Tx1y-sIgv zLxcWN4(KDXw|1#)ntL{Rn^joL0<+**)|UP|$9*!{3f%LUxQfdM zFk_)k6570S@sh95*(Pq@&c}ypW3yb;ps3{{N-<~kMk$tG4yzO=x|=ulYu8?~>X}gCTRld&%I#;WX-b(K*P-e**i=JEiyJEcOc#-{>=`A*7|un z5IgAXrO)k=&dxWwT5BGVzt#j79axoITDX)e?Pt@eM#@WJ$4U9KPwCj0>Ga~3&g{D6 zV;Jg7_({5d0m~v}@{K_f)nOh%b?dNE=E+=MRozNF8yoEhnA#4`t8L4^l%2kreDjKV z2F;~!F+a!_^F3S4V*^#%43qJ_2b+xB&&@Ss%Q`YiSCR3~78RY>NpjIl692~B^JP;a zukcb*XU^GKz6<^*`Tk*m8wy5dQ}5{;tnboG{2A;BH>L(!?%)I_qwk2?yc@395Nb!u zSN+lQ3WHR)BeY8)Cc=yW7Z8CwUVKhoLpBiaJ*Nnq+nXjBR%19eeXD*gJJ2-$==@Y) z6AK$nFQQ-iQgsbCv}#$r92s|m-r>9i*|AgCK^s?1!Q~H(T!Y4b_+*BK>#hTB-%wR# zhcy;EIa*k`ot$Do4G#T`CglbPA>F#9R9V=Sm0OqenQ(vJ;tR+BWWxQdUv|Lure$;5 zV=+s*`v8J`Umh%DtKjHgo0k9MrOY1~mzX)^lV+d8e@9S!`G_6k&$(Z9l7Y`DlxIGp zk;Hr>E{QS15&g3-7$JjHD;7o{2dPH%$_-Lof*6e@2O?^DO8<_|-`VRC$@0C&?a?}R zbD?`Z29i4cGP^9jCf4$9H?h9?9b>9cw2qP4m$!ZXWM=iri0(^%HV;9UUb)Q;F?qzV z{m}~NLgJiozCu=6;e3gQGzSHG5pMHyYfx@qC&kX{dmfSh_Av86fvfKbW&JkI+N-{m zPrCYUUA|*|4>MJWj)21wpTj4hOaJ&IdZ%^lK|XSwka3W`@_zjZm-ml}hWs<1m6akt z2XebMoIy|QYHfJ5`q-`ww`|I;4Wn}|DIIe{dDyHCFN@VLp0}j5h9}mBS_w9mE@m~T zwc$DS^RBS#Mzc2bKM8Bny728LHRr(XwTw>9c|MG13y~c0!W6qM+^%-}+q+bl-TGtA zX$-?;vH3tO^CkD}RG3SlHQtMlN1Ia_x2Ve))5cMj`C!&=OJ9znp1xVyy1ol=BL71n z7y3x^#&D5?kgqzV+0y=+Fvgu3Wg6q5J1_k*_QN#eL#n-&a0vvF~e>Au-J3@A5dma95i{Y-W0ay>moqm>&u@ zUF=9T-JIkvq0aPG__;nq4Q2_o)Nv7rOVLlGEyLroHm{#4-R?>}>KL?7_rRdpqj;4@ z_lKVUbR?!(qd)bl`G6rYEJxcw8g_3NQcJ8BO6v4h8yZvj*jLlj#6VulpGyTZzc*r_ z-4K15lG$hoOo~9uk%nX2WHn?ZaTs-t6^AbG{{4D&3(c`n8!hq&V_WuOzoW47vWv}Y z#akf$pqk?zqn+B>cFVP@u1OwU@2YE`Wx2WG|!WbM}?HrK7*VMFVs^9G-+L1 z;n(vLW4n@{?gmIQ7w0ExRw6BG{6wc@_y*P=JE9k4Dst4Z^U}XIlwIDe;qoP(OBOxO zygR97YBN*Y=$HMD|BXQ!CSwO0hk$--|HW_LZ}=@5hgOX+=W4$Z+zdZ1^Kym{kzvea z6g|jKF-^IvSBGWx&-k@)qvk0txBX0RZS%JF^qlb)3K*AV2v*qlPxxv4<-R{Dtx2p; zY)m|b;TqQV&ixiuNuXFbNJpVpk7_W-?Uzf#`8hu^J=qK?b1 zQXTu)_v>r+lEgFSJ6=rIdc5}s4k%du$t0B1YipW6IW}0(<3i=3{BX8)K_TLFA9J&2>nhDA&2qxFjxMiLVXBdrq$r=KE^<)4Jf6wkH> zjtGt~1n!d)IUMZg7VfBDxFkAf;YIVvX;8T1!Z}Ok)qzS^G4S?D=cgh40l9R+)Wjik z#Rjf~CJwHvhnu142|F!yUq6R%2VY`G=QY;Vr{zO4SB_u9W1zIV<{b_57S~<8xL!r< z6Yf|PYgkeTil@PxLoQf6Z_eC{^`urfApHl!wQVRr3zxh7)V@D*19dU`#}9PxQxFUc z9~53kg-sFY0fF#3*Rpk1E3ie>HG~tmf$BWaOniPdc3Q%%$bc*1KcDnV@ENswhtv+0 z*{g*5ROP`cg?;IgMKQ|yQu;HdgIwE~_Mq+aT5-voOB*hszf^zvVeniUVefQm$7DXo zB;Q}cQ@=1;x5Okfy>`_+5)MhXnuNP)z29G%t=lb6_;oWqK)+C%1LRYn&Q#Xcba!oe zSo+X^Ro;wTc~4}^TRi7V8c%!p(&6STzIa}=ZjQeBM~7QHkBG%}?DiL>DoYw^#e>XM zzQN@W=hk%R^b&0&a(++JK4sw!vNMIytO(iVPA@c#+%<8ydM~YG<33%J*T#5XoWFPx zZ9IRDOEvf+oGsAE!_s9YmCgxQ5wfFqg?b;7 ze%Q=Jm9<+R<(Rv|ykY;$FYpg`uV z<)7$WE83WAteuEhbl%+KFO1b+LMDh>!=uO7FQn)ZDXk2)FzMia&iKTn z#i^?;^OAYuR&3aoT4Gu%^9Q?7I_`2!N$ztHnPzRK4GQcb+UGIFg*Gz?{^$>8q162a z9inw>7JPUK*(V47ae`ee;eHQ0Ka8JF5+XU`&hZ40{ShwG8^x5`$Gh4vwFASIimS;n zJU`3uqJ`O0zcR*w()qE47e)0-;Jswt<(vs#cx5S1cmm-BaPd52ouU!LjY*1Q#F%D= z&{8+@mg_`tj5`rDm3eQmsZ5WUX62Wy%zPn|BVG;K%3!6<%x`P*8{l0veY1%(O<(kqxEwfKL$A@v#$e< z_O;ntN6)fmjqR=VYTIR2p?lSP9kejlSPYBxIG5}du@&f!pWW1l5W++^|?%}V4;JS+YNm)98b(({*jeh8W-p8x7_em;8?I-Y!c{hWS? z*PSO4&m>}Rhnu@(TlKbA{?KPVi5GWnrSedob=8(|#h))P57$2;&D~fY=@Z}m9-_Ie zjmqx|n}`V}zH04{u(~?GaH;VPZNGoc`@VAL-{a#bBJZ1gnQL~0olmRez{k#@tL-=W zvO2_Evx5M+t>nPD6dq)*`Ad3<@n9`{V5-?J)-ct4s8ZkLhj7hpK1^3~XRc|};mNJR zm}|yFXk9{^%&iTkGGljCi#-PxtNrj z)3}-w7v6N0i*)@WpWe8pdl7r~Oi%?qorYAFmv(v$Op*w3Lb!r?~d&K2iT< ztBN_Lt)^)(|HxHmd}jH&URgU|0Us_>F=L-Nou;9njM=@ZAD z`zxHKGM#&~oWH^tobB3Q;cpg7h>kCZ=nL^z_+8sHhDqzM@b|oWJNhdOP_6`{E=TVK zW0mMRr*i%ZCvMl{p7<-gQ&~EHg_~(=gks&-vqB+`yyZeWe}$*2=3kJ%!qIs}&$C6J z-lyn6c|~^$rt+_R+b&OA^fLDOUclP-?n)jSPTd1}s8KOH$iqAs+qFF0dWn&TQi#3~ zdAQcLOrAX4eb3J1p@*hWlT69cJ9&tUJ|_?IU$AHL@KdVd%R{%aPmaCgYrW;+GNGM3 z9IKjtLGo}!UePmb(I@mNdh54xMYp@kKT*GfJm8-r@kw(0%y9Fzp@Hi+BPN`yPSi+o z(SYUQ!i_zfo39#L9EhWt79__P-Ny=!cKireUo{KyuDJ7aX3pK>%@C&gvvYwPHmws_ zqD{c>5w{|A4o?4!$d%)#kACdy1;K};=uQqbgDn9xxW@mO&EeoIiZlk2D6$s^&FbHZv&&k_n8D_0mu9k8Spoa88YpNOXAfwMG46m*uSxtO|O9dV2@$KNad` z3uR&Kl1mz*i-`|C6}(sel#Tj0c!5NA-~r<#vU!T`vQt1LM{NBn0WZt}(3K}vUaN5;;;Y_~TWz=`i1dlp;S@RR#C+%R)y zZ)V=5GUn7mJDZ)}Uv1r1Tb8^D8J*aT_|Ml3N4jI-z#K=NIgWOBO9Cyo(57$qy5{}Q z>k|mg%5(IskEXn9$W9F#JIb6WoRH_8>>w&)7tFQNy3CT98gB9m{0cv9D*Uc#4qVwk zmXYKJw+>>n9p#goHPstBR3Lxu^y0*VQXs5I8>=Yg^*fW8BcC^Mk}Xm|?tP#gf9z*F zB=c<(gWI$ViCLSecBRD5b2sm7v>!lj^5(nT_>A!sKR5gYF6%V65f)6fo(!ZPa#5kl7|3IBJsG@j^Gj0I2p2++B>&laO zMeTY*pDW?HLAtJ6Pn0k=sXxw9_jZNW&~ka7el0vXyPiNJk1KiJ=U?LSmvbc+1CN5x z4g*sYu?WhKXce{^pazM03u2$9nmC(ZE%IO}gHJAS+G7k9UQ z=`7C*?ylD_H>=zo^wqoJZrA$iyYR*Or2(QZL|=WjtiD0a_qRTUa@8(B z%h5Z*eD1#_B-!=Lb#Lo&Pu4GQD@(V2DHWU?yZyv$&zSYg`q_r0T*7fRBwv)idRbo4 zx2cTe*lYR}Ju$E70+Cbs!|Egyef1&ZZ@o4#15de3=RMvJupGr3Ql$0TaW%Lv!x_X@ zui?(mdVC1;3Hxy{nnYBguz#RcyH8^VlJo(CE%}RJdn{xahIL zbb2&`Pp8sIvU+4$IPrLR)Fa{bfA1H3kb(;0 zPX}7ACLH||UYDNb`{_t>I$r`Z(yV`nyG!Hk9`fB

OtxEDQUOVQK;u%vSFfyF8|mb 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ǰK%081o&y>n_ZDho$@e{~cwCRiYcy$w_*PhJ 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

4w$u<> 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 }8#<*XZMr%w@c#wJc*SeG|W);Qt_U+*j{< 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 e6me7Fk-AtFB-eOl=!#*

8WdBWe2VC{ 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