{-# OPTIONS_GHC -fno-warn-missing-pattern-synonym-signatures#-}
{-# OPTIONS_GHC -fno-warn-orphans#-}
{-# OPTIONS_GHC -fno-warn-unused-imports#-}
{-# OPTIONS_HADDOCK not-home#-}
{-# LANGUAGE CPP                      #-}
{-# LANGUAGE DataKinds                #-}
{-# LANGUAGE FlexibleInstances        #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE MagicHash                #-}
{-# LANGUAGE PatternSynonyms          #-}
{-# LANGUAGE Strict                   #-}
{-# LANGUAGE TypeApplications         #-}
{-# LANGUAGE TypeFamilies             #-}
{-# LANGUAGE ViewPatterns             #-}
module Graphics.Vulkan.Core_1_1
       (-- * Vulkan 1.1 core API interface definitions.
        -- |
        --
        -- @api = vulkan@
        --
        -- @name = VK_VERSION_1_1@
        --
        -- @number = 1.1@
        --

        -- ** Device Initialization
        VkEnumerateInstanceVersion, pattern VkEnumerateInstanceVersion,
        HS_vkEnumerateInstanceVersion, PFN_vkEnumerateInstanceVersion,
        vkEnumerateInstanceVersion, vkEnumerateInstanceVersionUnsafe,
        vkEnumerateInstanceVersionSafe, VkResult(..),
        -- ** Promoted from VK_KHR_relaxed_block_layout, which has no API
        --

        -- ** Promoted from VK_KHR_storage_buffer_storage_class, which has no API
        --

        -- ** Originally based on VK_KHR_subgroup (extension 94), but the actual enum block used was, incorrectly, that of extension 95
        module Graphics.Vulkan.Marshal, AHardwareBuffer(), ANativeWindow(),
        CAMetalLayer(), VkBool32(..), VkDeviceAddress(..),
        VkDeviceSize(..), VkFlags(..), VkSampleMask(..),
        VkPhysicalDeviceLimits, VkPhysicalDeviceProperties,
        VkPhysicalDeviceProperties2, VkPhysicalDeviceSparseProperties,
        VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceType(..),
        VkSampleCountBitmask(..), VkSampleCountFlagBits(),
        VkSampleCountFlags(), VkShaderFloatControlsIndependence(..),
        VkShaderInfoTypeAMD(..), VkShaderStageBitmask(..),
        VkShaderCorePropertiesBitmaskAMD(..),
        VkShaderCorePropertiesFlagBitsAMD(),
        VkShaderCorePropertiesFlagsAMD(),
        VkShaderFloatControlsIndependenceKHR(..),
        VkShaderModuleCreateBitmask(..), VkShaderModuleCreateFlagBits(),
        VkShaderModuleCreateFlags(), VkShaderStageFlagBits(),
        VkShaderStageFlags(), VkStructureType(..),
        VkSubgroupFeatureBitmask(..), VkSubgroupFeatureFlagBits(),
        VkSubgroupFeatureFlags(),
        -- > #include "vk_platform.h"
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES,
        -- ** Promoted from VK_KHR_bind_memory2
        VkBindBufferMemoryInfo, VkBindImageMemoryInfo, -- > #include "vk_platform.h"
                                                       VkBindBufferMemory2,
        pattern VkBindBufferMemory2, HS_vkBindBufferMemory2,
        PFN_vkBindBufferMemory2, vkBindBufferMemory2,
        vkBindBufferMemory2Unsafe, vkBindBufferMemory2Safe,
        VkBindImageMemory2, pattern VkBindImageMemory2,
        HS_vkBindImageMemory2, PFN_vkBindImageMemory2, vkBindImageMemory2,
        vkBindImageMemory2Unsafe, vkBindImageMemory2Safe,
        VkAccelerationStructureKHR, VkAccelerationStructureKHR_T(),
        VkAccelerationStructureNV, VkAccelerationStructureNV_T(), VkBuffer,
        VkBufferView, VkBufferView_T(), VkBuffer_T(), VkCommandBuffer,
        VkCommandBuffer_T(), VkCommandPool, VkCommandPool_T(),
        VkDebugReportCallbackEXT, VkDebugReportCallbackEXT_T(),
        VkDebugUtilsMessengerEXT, VkDebugUtilsMessengerEXT_T(),
        VkDeferredOperationKHR, VkDeferredOperationKHR_T(),
        VkDescriptorPool, VkDescriptorPool_T(), VkDescriptorSet,
        VkDescriptorSetLayout, VkDescriptorSetLayout_T(),
        VkDescriptorSet_T(), VkDescriptorUpdateTemplate,
        VkDescriptorUpdateTemplateKHR, VkDescriptorUpdateTemplateKHR_T(),
        VkDescriptorUpdateTemplate_T(), VkDevice, VkDeviceMemory,
        VkDeviceMemory_T(), VkDevice_T(), VkDisplayKHR, VkDisplayKHR_T(),
        VkDisplayModeKHR, VkDisplayModeKHR_T(), VkEvent, VkEvent_T(),
        VkFence, VkFence_T(), VkFramebuffer, VkFramebuffer_T(), VkImage,
        VkImageView, VkImageView_T(), VkImage_T(),
        VkIndirectCommandsLayoutNV, VkIndirectCommandsLayoutNV_T(),
        VkInstance, VkInstance_T(), VkPerformanceConfigurationINTEL,
        VkPerformanceConfigurationINTEL_T(), VkPhysicalDevice,
        VkPhysicalDevice_T(), VkPipeline, VkPipelineCache,
        VkPipelineCache_T(), VkPipelineLayout, VkPipelineLayout_T(),
        VkPipeline_T(), VkPrivateDataSlotEXT, VkPrivateDataSlotEXT_T(),
        VkQueryPool, VkQueryPool_T(), VkQueue, VkQueue_T(), VkRenderPass,
        VkRenderPass_T(), VkSampler, VkSamplerYcbcrConversion,
        VkSamplerYcbcrConversionKHR, VkSamplerYcbcrConversionKHR_T(),
        VkSamplerYcbcrConversion_T(), VkSampler_T(), VkSemaphore,
        VkSemaphore_T(), VkShaderModule, VkShaderModule_T(), VkSurfaceKHR,
        VkSurfaceKHR_T(), VkSwapchainKHR, VkSwapchainKHR_T(),
        VkValidationCacheEXT, VkValidationCacheEXT_T(),
#ifdef VK_ENABLE_BETA_EXTENSIONS
        VkBindAccelerationStructureMemoryInfoNV,
#endif
        VkBindBufferMemoryDeviceGroupInfo,
        VkBindBufferMemoryDeviceGroupInfoKHR, VkBindBufferMemoryInfoKHR,
        VkBindImageMemoryDeviceGroupInfo,
        VkBindImageMemoryDeviceGroupInfoKHR, VkBindImageMemoryInfoKHR,
        VkBindImageMemorySwapchainInfoKHR, VkBindImagePlaneMemoryInfo,
        VkBindImagePlaneMemoryInfoKHR, VkBindIndexBufferIndirectCommandNV,
        VkBindShaderGroupIndirectCommandNV, VkBindSparseInfo,
        VkBindVertexBufferIndirectCommandNV,
        pattern VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
        pattern VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
        pattern VK_IMAGE_CREATE_ALIAS_BIT,
        VkAndroidSurfaceCreateFlagsKHR(..), VkBufferViewCreateFlags(..),
        VkBuildAccelerationStructureFlagsNV(..),
        VkCommandPoolTrimFlags(..), VkCommandPoolTrimFlagsKHR(..),
        VkDebugUtilsMessengerCallbackDataFlagsEXT(..),
        VkDebugUtilsMessengerCreateFlagsEXT(..),
        VkDescriptorBindingFlagsEXT(..), VkDescriptorPoolResetFlags(..),
        VkDescriptorUpdateTemplateCreateFlags(..),
        VkDescriptorUpdateTemplateCreateFlagsKHR(..),
        VkDeviceCreateFlags(..), VkDirectFBSurfaceCreateFlagsEXT(..),
        VkDisplayModeCreateFlagsKHR(..),
        VkDisplaySurfaceCreateFlagsKHR(..), VkEventCreateFlags(..),
        VkExternalFenceFeatureFlagsKHR(..),
        VkExternalFenceHandleTypeFlagsKHR(..),
        VkExternalMemoryFeatureFlagsKHR(..),
        VkExternalMemoryHandleTypeFlagsKHR(..),
        VkExternalSemaphoreFeatureFlagsKHR(..),
        VkExternalSemaphoreHandleTypeFlagsKHR(..),
        VkFenceImportFlagsKHR(..), VkGeometryFlagsNV(..),
        VkGeometryInstanceFlagsNV(..), VkHeadlessSurfaceCreateFlagsEXT(..),
        VkIOSSurfaceCreateFlagsMVK(..),
        VkImagePipeSurfaceCreateFlagsFUCHSIA(..),
        VkInstanceCreateFlags(..), VkMacOSSurfaceCreateFlagsMVK(..),
        VkMemoryAllocateFlagsKHR(..), VkMemoryMapFlags(..),
        VkMetalSurfaceCreateFlagsEXT(..), VkPeerMemoryFeatureFlagsKHR(..),
        VkPipelineColorBlendStateCreateFlags(..),
        VkPipelineCoverageModulationStateCreateFlagsNV(..),
        VkPipelineCoverageReductionStateCreateFlagsNV(..),
        VkPipelineCoverageToColorStateCreateFlagsNV(..),
        VkPipelineDepthStencilStateCreateFlags(..),
        VkPipelineDiscardRectangleStateCreateFlagsEXT(..),
        VkPipelineDynamicStateCreateFlags(..),
        VkPipelineInputAssemblyStateCreateFlags(..),
        VkPipelineLayoutCreateFlags(..),
        VkPipelineMultisampleStateCreateFlags(..),
        VkPipelineRasterizationConservativeStateCreateFlagsEXT(..),
        VkPipelineRasterizationDepthClipStateCreateFlagsEXT(..),
        VkPipelineRasterizationStateCreateFlags(..),
        VkPipelineRasterizationStateStreamCreateFlagsEXT(..),
        VkPipelineTessellationStateCreateFlags(..),
        VkPipelineVertexInputStateCreateFlags(..),
        VkPipelineViewportStateCreateFlags(..),
        VkPipelineViewportSwizzleStateCreateFlagsNV(..),
        VkQueryPoolCreateFlags(..), VkResolveModeFlagsKHR(..),
        VkSemaphoreCreateFlags(..), VkSemaphoreImportFlagsKHR(..),
        VkSemaphoreWaitFlagsKHR(..),
        VkStreamDescriptorSurfaceCreateFlagsGGP(..),
        VkValidationCacheCreateFlagsEXT(..), VkViSurfaceCreateFlagsNN(..),
        VkWaylandSurfaceCreateFlagsKHR(..),
        VkWin32SurfaceCreateFlagsKHR(..), VkXcbSurfaceCreateFlagsKHR(..),
        VkXlibSurfaceCreateFlagsKHR(..), VkDeviceCreateInfo,
        VkDeviceDiagnosticsConfigBitmaskNV(..), VkDeviceEventTypeEXT(..),
        VkDeviceGroupPresentModeBitmaskKHR(..), VkDeviceCreateFlagBits(..),
        VkDeviceDiagnosticsConfigFlagBitsNV(),
        VkDeviceDiagnosticsConfigFlagsNV(),
        VkDeviceGroupPresentModeFlagBitsKHR(),
        VkDeviceGroupPresentModeFlagsKHR(), VkDeviceQueueCreateBitmask(..),
        VkDeviceQueueCreateFlagBits(), VkDeviceQueueCreateFlags(),
        VkDeviceQueueCreateInfo, VkPhysicalDevice16BitStorageFeatures,
        VkPhysicalDeviceFeatures, VkPhysicalDeviceFeatures2,
        -- > #include "vk_platform.h"
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
        -- ** Promoted from VK_KHR_dedicated_allocation
        VkMemoryAllocateInfo, VkMemoryDedicatedAllocateInfo,
        VkMemoryDedicatedRequirements, VkMemoryRequirements,
        VkMemoryRequirements2,
        -- > #include "vk_platform.h"
        pattern VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
        pattern VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
        VkClearColorValue, VkClearDepthStencilValue, VkClearValue,
        VkCommandBufferBeginInfo, VkCommandBufferInheritanceInfo,
        VkCommandBufferLevel(..), VkCommandBufferResetBitmask(..),
        VkCommandBufferUsageBitmask(..), VkCommandPoolCreateBitmask(..),
        VkCommandPoolResetBitmask(..), VkCommandBufferResetFlagBits(),
        VkCommandBufferResetFlags(), VkCommandBufferUsageFlagBits(),
        VkCommandBufferUsageFlags(), VkCommandPoolCreateFlagBits(),
        VkCommandPoolCreateFlags(), VkCommandPoolResetFlagBits(),
        VkCommandPoolResetFlags(), VkDeviceGroupBindSparseInfo,
        VkDeviceGroupCommandBufferBeginInfo,
        VkDeviceGroupRenderPassBeginInfo, VkDeviceGroupSubmitInfo,
        VkExtent2D, VkExtent3D, VkImageAspectBitmask(..),
        VkImageCreateBitmask(..), VkImageLayout(..), VkImageTiling(..),
        VkImageType(..), VkImageUsageBitmask(..), VkImageViewType(..),
        VkImageAspectFlagBits(), VkImageAspectFlags(),
        VkImageCreateFlagBits(), VkImageCreateFlags(),
        VkImageUsageFlagBits(), VkImageUsageFlags(),
        VkImageViewCreateBitmask(..), VkImageViewCreateFlagBits(),
        VkImageViewCreateFlags(), VkImageSubresource,
        VkMemoryAllocateBitmask(..), VkMemoryHeapBitmask(..),
        VkMemoryOverallocationBehaviorAMD(..), VkMemoryPropertyBitmask(..),
        VkMemoryAllocateFlagBits(), VkMemoryAllocateFlagBitsKHR(..),
        VkMemoryAllocateFlags(), VkMemoryHeapFlagBits(),
        VkMemoryHeapFlags(), VkMemoryPropertyFlagBits(),
        VkMemoryPropertyFlags(), VkMemoryAllocateFlagsInfo, VkOffset2D,
        VkOffset3D, VkPeerMemoryFeatureBitmask(..),
        VkPeerMemoryFeatureFlagBits(), VkPeerMemoryFeatureFlagBitsKHR(..),
        VkPeerMemoryFeatureFlags(), VkPipelineBindPoint(..),
        VkPipelineCacheHeaderVersion(..), VkPipelineCreateBitmask(..),
        VkPipelineCreationFeedbackBitmaskEXT(..),
        VkPipelineExecutableStatisticFormatKHR(..),
        VkPipelineStageBitmask(..), VkPipelineCacheCreateBitmask(..),
        VkPipelineCacheCreateFlagBits(), VkPipelineCacheCreateFlags(),
        VkPipelineCompilerControlBitmaskAMD(..),
        VkPipelineCompilerControlFlagBitsAMD(),
        VkPipelineCompilerControlFlagsAMD(), VkPipelineCreateFlagBits(),
        VkPipelineCreateFlags(), VkPipelineCreationFeedbackFlagBitsEXT(),
        VkPipelineCreationFeedbackFlagsEXT(),
        VkPipelineShaderStageCreateBitmask(..),
        VkPipelineShaderStageCreateFlagBits(),
        VkPipelineShaderStageCreateFlags(), VkPipelineStageFlagBits(),
        VkPipelineStageFlags(), VkQueryControlBitmask(..),
        VkQueryPipelineStatisticBitmask(..),
        VkQueryPoolSamplingModeINTEL(..), VkQueryResultBitmask(..),
        VkQueryType(..), VkQueryControlFlagBits(), VkQueryControlFlags(),
        VkQueryPipelineStatisticFlagBits(),
        VkQueryPipelineStatisticFlags(), VkQueryPoolCreateFlagBits(..),
        VkQueryResultFlagBits(), VkQueryResultFlags(), VkRect2D,
        VkRenderPassBeginInfo, VkSparseBufferMemoryBindInfo,
        VkSparseImageMemoryBind, VkSparseImageMemoryBindInfo,
        VkSparseImageOpaqueMemoryBindInfo, VkSparseMemoryBind,
        VkSparseImageFormatBitmask(..), VkSparseMemoryBindBitmask(..),
        VkSparseImageFormatFlagBits(), VkSparseImageFormatFlags(),
        VkSparseMemoryBindFlagBits(), VkSparseMemoryBindFlags(),
        VkSubmitInfo, -- > #include "vk_platform.h"
                      VkGetDeviceGroupPeerMemoryFeatures,
        pattern VkGetDeviceGroupPeerMemoryFeatures,
        HS_vkGetDeviceGroupPeerMemoryFeatures,
        PFN_vkGetDeviceGroupPeerMemoryFeatures,
        vkGetDeviceGroupPeerMemoryFeatures,
        vkGetDeviceGroupPeerMemoryFeaturesUnsafe,
        vkGetDeviceGroupPeerMemoryFeaturesSafe, VkCmdSetDeviceMask,
        pattern VkCmdSetDeviceMask, HS_vkCmdSetDeviceMask,
        PFN_vkCmdSetDeviceMask, vkCmdSetDeviceMask,
        vkCmdSetDeviceMaskUnsafe, vkCmdSetDeviceMaskSafe,
        VkCmdDispatchBase, pattern VkCmdDispatchBase, HS_vkCmdDispatchBase,
        PFN_vkCmdDispatchBase, vkCmdDispatchBase, vkCmdDispatchBaseUnsafe,
        vkCmdDispatchBaseSafe,
        pattern VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
        pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
        pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
        pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO,
        pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO,
        pattern VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
        pattern VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
        pattern VK_PIPELINE_CREATE_DISPATCH_BASE,
        pattern VK_DEPENDENCY_DEVICE_GROUP_BIT,
        -- > #include "vk_platform.h"
        pattern VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
        pattern VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
        pattern VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
        VkDeviceGroupDeviceCreateInfo, VkPhysicalDeviceGroupProperties,
        -- > #include "vk_platform.h"
        VkEnumeratePhysicalDeviceGroups,
        pattern VkEnumeratePhysicalDeviceGroups,
        HS_vkEnumeratePhysicalDeviceGroups,
        PFN_vkEnumeratePhysicalDeviceGroups,
        vkEnumeratePhysicalDeviceGroups,
        vkEnumeratePhysicalDeviceGroupsUnsafe,
        vkEnumeratePhysicalDeviceGroupsSafe,
        VkPhysicalDevice16BitStorageFeaturesKHR,
        VkPhysicalDevice4444FormatsFeaturesEXT,
        VkPhysicalDevice8BitStorageFeatures,
        VkPhysicalDevice8BitStorageFeaturesKHR,
        VkPhysicalDeviceASTCDecodeFeaturesEXT,
        VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT,
        VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT,
        VkPhysicalDeviceBufferAddressFeaturesEXT,
        VkPhysicalDeviceBufferDeviceAddressFeatures,
        VkPhysicalDeviceBufferDeviceAddressFeaturesEXT,
        VkPhysicalDeviceBufferDeviceAddressFeaturesKHR,
        VkPhysicalDeviceCoherentMemoryFeaturesAMD,
        VkPhysicalDeviceComputeShaderDerivativesFeaturesNV,
        VkPhysicalDeviceConditionalRenderingFeaturesEXT,
        VkPhysicalDeviceConservativeRasterizationPropertiesEXT,
        VkPhysicalDeviceCooperativeMatrixFeaturesNV,
        VkPhysicalDeviceCooperativeMatrixPropertiesNV,
        VkPhysicalDeviceCornerSampledImageFeaturesNV,
        VkPhysicalDeviceCoverageReductionModeFeaturesNV,
        VkPhysicalDeviceCustomBorderColorFeaturesEXT,
        VkPhysicalDeviceCustomBorderColorPropertiesEXT,
        VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV,
        VkPhysicalDeviceDepthClipEnableFeaturesEXT,
        VkPhysicalDeviceDepthStencilResolveProperties,
        VkPhysicalDeviceDepthStencilResolvePropertiesKHR,
        VkPhysicalDeviceDescriptorIndexingFeatures,
        VkPhysicalDeviceDescriptorIndexingFeaturesEXT,
        VkPhysicalDeviceDescriptorIndexingProperties,
        VkPhysicalDeviceDescriptorIndexingPropertiesEXT,
        VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV,
        VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV,
        VkPhysicalDeviceDiagnosticsConfigFeaturesNV,
        VkPhysicalDeviceDiscardRectanglePropertiesEXT,
        VkPhysicalDeviceDriverProperties,
        VkPhysicalDeviceDriverPropertiesKHR,
        VkPhysicalDeviceExclusiveScissorFeaturesNV,
        VkPhysicalDeviceExtendedDynamicStateFeaturesEXT,
        VkPhysicalDeviceExternalBufferInfo,
        VkPhysicalDeviceExternalBufferInfoKHR,
        VkPhysicalDeviceExternalFenceInfo,
        VkPhysicalDeviceExternalFenceInfoKHR,
        VkPhysicalDeviceExternalImageFormatInfo,
        VkPhysicalDeviceExternalImageFormatInfoKHR,
        VkPhysicalDeviceExternalMemoryHostPropertiesEXT,
        VkPhysicalDeviceExternalSemaphoreInfo,
        VkPhysicalDeviceExternalSemaphoreInfoKHR,
        VkPhysicalDeviceFeatures2KHR,
        VkPhysicalDeviceFloat16Int8FeaturesKHR,
        VkPhysicalDeviceFloatControlsProperties,
        VkPhysicalDeviceFloatControlsPropertiesKHR,
        VkPhysicalDeviceFragmentDensityMap2FeaturesEXT,
        VkPhysicalDeviceFragmentDensityMap2PropertiesEXT,
        VkPhysicalDeviceFragmentDensityMapFeaturesEXT,
        VkPhysicalDeviceFragmentDensityMapPropertiesEXT,
        VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV,
        VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT,
        VkPhysicalDeviceGroupPropertiesKHR,
        VkPhysicalDeviceHostQueryResetFeatures,
        VkPhysicalDeviceHostQueryResetFeaturesEXT,
        VkPhysicalDeviceIDProperties, VkPhysicalDeviceIDPropertiesKHR,
        VkPhysicalDeviceImageDrmFormatModifierInfoEXT,
        VkPhysicalDeviceImageFormatInfo2,
        VkPhysicalDeviceImageFormatInfo2KHR,
        VkPhysicalDeviceImageRobustnessFeaturesEXT,
        VkPhysicalDeviceImageViewImageFormatInfoEXT,
        VkPhysicalDeviceImagelessFramebufferFeatures,
        VkPhysicalDeviceImagelessFramebufferFeaturesKHR,
        VkPhysicalDeviceIndexTypeUint8FeaturesEXT,
        VkPhysicalDeviceInlineUniformBlockFeaturesEXT,
        VkPhysicalDeviceInlineUniformBlockPropertiesEXT,
        VkPhysicalDeviceLineRasterizationFeaturesEXT,
        VkPhysicalDeviceLineRasterizationPropertiesEXT,
        VkPhysicalDeviceMaintenance3Properties,
        VkPhysicalDeviceMaintenance3PropertiesKHR,
        VkPhysicalDeviceMemoryBudgetPropertiesEXT,
        VkPhysicalDeviceMemoryPriorityFeaturesEXT,
        VkPhysicalDeviceMemoryProperties,
        VkPhysicalDeviceMemoryProperties2,
        VkPhysicalDeviceMemoryProperties2KHR,
        VkPhysicalDeviceMeshShaderFeaturesNV,
        VkPhysicalDeviceMeshShaderPropertiesNV,
        VkPhysicalDeviceMultiviewFeatures,
        VkPhysicalDeviceMultiviewFeaturesKHR,
        VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX,
        VkPhysicalDeviceMultiviewProperties,
        VkPhysicalDeviceMultiviewPropertiesKHR,
        VkPhysicalDevicePCIBusInfoPropertiesEXT,
        VkPhysicalDevicePerformanceQueryFeaturesKHR,
        VkPhysicalDevicePerformanceQueryPropertiesKHR,
        VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT,
        VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR,
        VkPhysicalDevicePointClippingProperties,
        VkPhysicalDevicePointClippingPropertiesKHR,
        VkPhysicalDevicePrivateDataFeaturesEXT,
        VkPhysicalDeviceProperties2KHR,
        VkPhysicalDeviceProtectedMemoryFeatures,
        VkPhysicalDeviceProtectedMemoryProperties,
        VkPhysicalDevicePushDescriptorPropertiesKHR,
        VkPhysicalDeviceRayTracingPropertiesNV,
        VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV,
        VkPhysicalDeviceRobustness2FeaturesEXT,
        VkPhysicalDeviceRobustness2PropertiesEXT,
        VkPhysicalDeviceSampleLocationsPropertiesEXT,
        VkPhysicalDeviceSamplerFilterMinmaxProperties,
        VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT,
        VkPhysicalDeviceSamplerYcbcrConversionFeatures,
        VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR,
        VkPhysicalDeviceScalarBlockLayoutFeatures,
        VkPhysicalDeviceScalarBlockLayoutFeaturesEXT,
        VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures,
        VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR,
        VkPhysicalDeviceShaderAtomicFloatFeaturesEXT,
        VkPhysicalDeviceShaderAtomicInt64Features,
        VkPhysicalDeviceShaderAtomicInt64FeaturesKHR,
        VkPhysicalDeviceShaderClockFeaturesKHR,
        VkPhysicalDeviceShaderCoreProperties2AMD,
        VkPhysicalDeviceShaderCorePropertiesAMD,
        VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT,
        VkPhysicalDeviceShaderDrawParameterFeatures,
        VkPhysicalDeviceShaderDrawParametersFeatures,
        VkPhysicalDeviceShaderFloat16Int8Features,
        VkPhysicalDeviceShaderFloat16Int8FeaturesKHR,
        VkPhysicalDeviceShaderImageFootprintFeaturesNV,
        VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL,
        VkPhysicalDeviceShaderSMBuiltinsFeaturesNV,
        VkPhysicalDeviceShaderSMBuiltinsPropertiesNV,
        VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures,
        VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR,
        VkPhysicalDeviceShadingRateImageFeaturesNV,
        VkPhysicalDeviceShadingRateImagePropertiesNV,
        VkPhysicalDeviceSparseImageFormatInfo2,
        VkPhysicalDeviceSparseImageFormatInfo2KHR,
        VkPhysicalDeviceSubgroupSizeControlFeaturesEXT,
        VkPhysicalDeviceSubgroupSizeControlPropertiesEXT,
        VkPhysicalDeviceSurfaceInfo2KHR,
        VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT,
        VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT,
        VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT,
        VkPhysicalDeviceTimelineSemaphoreFeatures,
        VkPhysicalDeviceTimelineSemaphoreFeaturesKHR,
        VkPhysicalDeviceTimelineSemaphoreProperties,
        VkPhysicalDeviceTimelineSemaphorePropertiesKHR,
        VkPhysicalDeviceToolPropertiesEXT,
        VkPhysicalDeviceTransformFeedbackFeaturesEXT,
        VkPhysicalDeviceTransformFeedbackPropertiesEXT,
        VkPhysicalDeviceUniformBufferStandardLayoutFeatures,
        VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR,
        VkPhysicalDeviceVariablePointerFeatures,
        VkPhysicalDeviceVariablePointerFeaturesKHR,
        VkPhysicalDeviceVariablePointersFeatures,
        VkPhysicalDeviceVariablePointersFeaturesKHR,
        VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT,
        VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT,
        VkPhysicalDeviceVulkan11Features,
        VkPhysicalDeviceVulkan11Properties,
        VkPhysicalDeviceVulkan12Features,
        VkPhysicalDeviceVulkan12Properties,
        VkPhysicalDeviceVulkanMemoryModelFeatures,
        VkPhysicalDeviceVulkanMemoryModelFeaturesKHR,
        VkPhysicalDeviceYcbcrImageArraysFeaturesEXT,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES,
        pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO,
        pattern VK_MAX_DEVICE_GROUP_SIZE,
        pattern VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,
        -- ** Promoted from VK_KHR_get_memory_requirements2
        VkBufferMemoryRequirementsInfo2, VkImageMemoryRequirementsInfo2,
        VkImageSparseMemoryRequirementsInfo2,
        VkSparseImageFormatProperties, VkSparseImageMemoryRequirements,
        VkSparseImageMemoryRequirements2, -- > #include "vk_platform.h"
                                          VkGetImageMemoryRequirements2,
        pattern VkGetImageMemoryRequirements2,
        HS_vkGetImageMemoryRequirements2,
        PFN_vkGetImageMemoryRequirements2, vkGetImageMemoryRequirements2,
        vkGetImageMemoryRequirements2Unsafe,
        vkGetImageMemoryRequirements2Safe, VkGetBufferMemoryRequirements2,
        pattern VkGetBufferMemoryRequirements2,
        HS_vkGetBufferMemoryRequirements2,
        PFN_vkGetBufferMemoryRequirements2, vkGetBufferMemoryRequirements2,
        vkGetBufferMemoryRequirements2Unsafe,
        vkGetBufferMemoryRequirements2Safe,
        VkGetImageSparseMemoryRequirements2,
        pattern VkGetImageSparseMemoryRequirements2,
        HS_vkGetImageSparseMemoryRequirements2,
        PFN_vkGetImageSparseMemoryRequirements2,
        vkGetImageSparseMemoryRequirements2,
        vkGetImageSparseMemoryRequirements2Unsafe,
        vkGetImageSparseMemoryRequirements2Safe, VkBufferCopy,
        VkBufferCreateInfo, VkBufferDeviceAddressCreateInfoEXT,
        VkBufferDeviceAddressInfo, VkBufferDeviceAddressInfoEXT,
        VkBufferDeviceAddressInfoKHR, VkBufferImageCopy,
        VkBufferMemoryBarrier, VkBufferMemoryRequirementsInfo2KHR,
        VkBufferOpaqueCaptureAddressCreateInfo,
        VkBufferOpaqueCaptureAddressCreateInfoKHR, VkBufferViewCreateInfo,
        VkImageBlit, VkImageCopy, VkImageCreateInfo,
        VkImageDrmFormatModifierExplicitCreateInfoEXT,
        VkImageDrmFormatModifierListCreateInfoEXT,
        VkImageDrmFormatModifierPropertiesEXT, VkImageFormatListCreateInfo,
        VkImageFormatListCreateInfoKHR, VkImageFormatProperties,
        VkImageFormatProperties2, VkImageFormatProperties2KHR,
        VkImageMemoryBarrier, VkImageMemoryRequirementsInfo2KHR,
        VkImagePlaneMemoryRequirementsInfo,
        VkImagePlaneMemoryRequirementsInfoKHR, VkImageResolve,
        VkImageSparseMemoryRequirementsInfo2KHR,
        VkImageStencilUsageCreateInfo, VkImageStencilUsageCreateInfoEXT,
        VkImageSubresourceLayers, VkImageSubresourceRange,
        VkImageSwapchainCreateInfoKHR, VkImageViewASTCDecodeModeEXT,
        VkImageViewAddressPropertiesNVX, VkImageViewCreateInfo,
        VkImageViewHandleInfoNVX, VkImageViewUsageCreateInfo,
        VkImageViewUsageCreateInfoKHR, VkMemoryAllocateFlagsInfoKHR,
        VkMemoryBarrier, VkMemoryDedicatedAllocateInfoKHR,
        VkMemoryDedicatedRequirementsKHR, VkMemoryFdPropertiesKHR,
        VkMemoryGetFdInfoKHR, VkMemoryHeap,
        VkMemoryHostPointerPropertiesEXT,
        VkMemoryOpaqueCaptureAddressAllocateInfo,
        VkMemoryOpaqueCaptureAddressAllocateInfoKHR,
        VkMemoryPriorityAllocateInfoEXT, VkMemoryRequirements2KHR,
        VkMemoryType, VkSparseImageFormatProperties2,
        VkSparseImageFormatProperties2KHR,
        VkSparseImageMemoryRequirements2KHR,
        pattern VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
        pattern VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
        pattern VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
        pattern VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
        pattern VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
        VkFormat(..), VkFormatFeatureBitmask(..),
        VkFormatFeatureFlagBits(), VkFormatFeatureFlags(),
        VkFormatProperties, VkFormatProperties2, VkQueueFamilyProperties,
        VkQueueFamilyProperties2, VkQueueBitmask(..),
        VkQueueGlobalPriorityEXT(..), VkQueueFlagBits(), VkQueueFlags(),
        -- > #include "vk_platform.h"
        VkGetPhysicalDeviceFeatures2, pattern VkGetPhysicalDeviceFeatures2,
        HS_vkGetPhysicalDeviceFeatures2, PFN_vkGetPhysicalDeviceFeatures2,
        vkGetPhysicalDeviceFeatures2, vkGetPhysicalDeviceFeatures2Unsafe,
        vkGetPhysicalDeviceFeatures2Safe, VkGetPhysicalDeviceProperties2,
        pattern VkGetPhysicalDeviceProperties2,
        HS_vkGetPhysicalDeviceProperties2,
        PFN_vkGetPhysicalDeviceProperties2, vkGetPhysicalDeviceProperties2,
        vkGetPhysicalDeviceProperties2Unsafe,
        vkGetPhysicalDeviceProperties2Safe,
        VkGetPhysicalDeviceFormatProperties2,
        pattern VkGetPhysicalDeviceFormatProperties2,
        HS_vkGetPhysicalDeviceFormatProperties2,
        PFN_vkGetPhysicalDeviceFormatProperties2,
        vkGetPhysicalDeviceFormatProperties2,
        vkGetPhysicalDeviceFormatProperties2Unsafe,
        vkGetPhysicalDeviceFormatProperties2Safe,
        VkGetPhysicalDeviceImageFormatProperties2,
        pattern VkGetPhysicalDeviceImageFormatProperties2,
        HS_vkGetPhysicalDeviceImageFormatProperties2,
        PFN_vkGetPhysicalDeviceImageFormatProperties2,
        vkGetPhysicalDeviceImageFormatProperties2,
        vkGetPhysicalDeviceImageFormatProperties2Unsafe,
        vkGetPhysicalDeviceImageFormatProperties2Safe,
        VkGetPhysicalDeviceQueueFamilyProperties2,
        pattern VkGetPhysicalDeviceQueueFamilyProperties2,
        HS_vkGetPhysicalDeviceQueueFamilyProperties2,
        PFN_vkGetPhysicalDeviceQueueFamilyProperties2,
        vkGetPhysicalDeviceQueueFamilyProperties2,
        vkGetPhysicalDeviceQueueFamilyProperties2Unsafe,
        vkGetPhysicalDeviceQueueFamilyProperties2Safe,
        VkGetPhysicalDeviceMemoryProperties2,
        pattern VkGetPhysicalDeviceMemoryProperties2,
        HS_vkGetPhysicalDeviceMemoryProperties2,
        PFN_vkGetPhysicalDeviceMemoryProperties2,
        vkGetPhysicalDeviceMemoryProperties2,
        vkGetPhysicalDeviceMemoryProperties2Unsafe,
        vkGetPhysicalDeviceMemoryProperties2Safe,
        VkGetPhysicalDeviceSparseImageFormatProperties2,
        pattern VkGetPhysicalDeviceSparseImageFormatProperties2,
        HS_vkGetPhysicalDeviceSparseImageFormatProperties2,
        PFN_vkGetPhysicalDeviceSparseImageFormatProperties2,
        vkGetPhysicalDeviceSparseImageFormatProperties2,
        vkGetPhysicalDeviceSparseImageFormatProperties2Unsafe,
        vkGetPhysicalDeviceSparseImageFormatProperties2Safe,
        VkDeviceDiagnosticsConfigCreateInfoNV, VkDeviceEventInfoEXT,
        VkDeviceGroupBindSparseInfoKHR,
        VkDeviceGroupCommandBufferBeginInfoKHR,
        VkDeviceGroupDeviceCreateInfoKHR,
        VkDeviceGroupPresentCapabilitiesKHR, VkDeviceGroupPresentInfoKHR,
        VkDeviceGroupRenderPassBeginInfoKHR, VkDeviceGroupSubmitInfoKHR,
        VkDeviceGroupSwapchainCreateInfoKHR,
        VkDeviceMemoryOpaqueCaptureAddressInfo,
        VkDeviceMemoryOpaqueCaptureAddressInfoKHR,
        VkDeviceMemoryOverallocationCreateInfoAMD,
        VkDevicePrivateDataCreateInfoEXT,
        VkDeviceQueueGlobalPriorityCreateInfoEXT, VkDeviceQueueInfo2,
        VkFormatProperties2KHR, VkQueueFamilyCheckpointPropertiesNV,
        VkQueueFamilyProperties2KHR,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
        pattern VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
        pattern VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
        pattern VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
        pattern VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
        -- ** Promoted from VK_KHR_maintenance1
        --
        -- |
        -- > #include "vk_platform.h"
        VkTrimCommandPool, pattern VkTrimCommandPool, HS_vkTrimCommandPool,
        PFN_vkTrimCommandPool, vkTrimCommandPool, vkTrimCommandPoolUnsafe,
        vkTrimCommandPoolSafe, pattern VK_ERROR_OUT_OF_POOL_MEMORY,
        pattern VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
        pattern VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
        pattern VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
        -- ** Promoted from VK_KHR_maintenance2
        VkAccessBitmask(..), VkAccessFlagBits(), VkAccessFlags(),
        VkAttachmentDescription, VkAttachmentDescriptionBitmask(..),
        VkAttachmentLoadOp(..), VkAttachmentStoreOp(..),
        VkAttachmentDescriptionFlagBits(), VkAttachmentDescriptionFlags(),
        VkAttachmentReference, VkComponentMapping, VkComponentSwizzle(..),
        VkComponentTypeNV(..), VkDependencyBitmask(..),
        VkDependencyFlagBits(), VkDependencyFlags(),
        VkInputAttachmentAspectReference,
        VkPipelineTessellationDomainOriginStateCreateInfo,
        VkPipelineTessellationStateCreateInfo, VkPointClippingBehavior(..),
        VkPointClippingBehaviorKHR(..), VkRenderPassCreateBitmask(..),
        VkRenderPassCreateFlagBits(), VkRenderPassCreateFlags(),
        VkRenderPassCreateInfo,
        VkRenderPassInputAttachmentAspectCreateInfo, VkSubpassDependency,
        VkSubpassDescription, VkSubpassContents(..),
        VkSubpassDescriptionBitmask(..), VkSubpassDescriptionFlagBits(),
        VkSubpassDescriptionFlags(), VkTessellationDomainOrigin(..),
        VkTessellationDomainOriginKHR(..),
        -- > #include "vk_platform.h"
        pattern VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
        pattern VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
        pattern VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
        pattern VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
        pattern VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
        pattern VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
        pattern VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
        VkRenderPassMultiviewCreateInfo,
        -- > #include "vk_platform.h"
        pattern VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
        pattern VK_DEPENDENCY_VIEW_LOCAL_BIT,
        -- > #include "vk_platform.h"
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES,
        VkProtectedSubmitInfo, -- > #include "vk_platform.h"
                               VkGetDeviceQueue2,
        pattern VkGetDeviceQueue2, HS_vkGetDeviceQueue2,
        PFN_vkGetDeviceQueue2, vkGetDeviceQueue2, vkGetDeviceQueue2Unsafe,
        vkGetDeviceQueue2Safe,
        pattern VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES,
        pattern VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2,
        pattern VK_QUEUE_PROTECTED_BIT,
        pattern VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT,
        pattern VK_MEMORY_PROPERTY_PROTECTED_BIT,
        pattern VK_BUFFER_CREATE_PROTECTED_BIT,
        pattern VK_IMAGE_CREATE_PROTECTED_BIT,
        pattern VK_COMMAND_POOL_CREATE_PROTECTED_BIT, VkBorderColor(..),
        VkChromaLocation(..), VkChromaLocationKHR(..), VkCompareOp(..),
        VkFilter(..), VkSamplerAddressMode(..), VkSamplerMipmapMode(..),
        VkSamplerReductionMode(..), VkSamplerYcbcrModelConversion(..),
        VkSamplerYcbcrRange(..), VkSamplerCreateBitmask(..),
        VkSamplerCreateFlagBits(), VkSamplerCreateFlags(),
        VkSamplerReductionModeEXT(..),
        VkSamplerYcbcrModelConversionKHR(..), VkSamplerYcbcrRangeKHR(..),
        VkSamplerCreateInfo, VkSamplerYcbcrConversionCreateInfo,
        VkSamplerYcbcrConversionImageFormatProperties,
        VkSamplerYcbcrConversionInfo, -- > #include "vk_platform.h"
                                      VkCreateSamplerYcbcrConversion,
        pattern VkCreateSamplerYcbcrConversion,
        HS_vkCreateSamplerYcbcrConversion,
        PFN_vkCreateSamplerYcbcrConversion, vkCreateSamplerYcbcrConversion,
        vkCreateSamplerYcbcrConversionUnsafe,
        vkCreateSamplerYcbcrConversionSafe,
        VkDestroySamplerYcbcrConversion,
        pattern VkDestroySamplerYcbcrConversion,
        HS_vkDestroySamplerYcbcrConversion,
        PFN_vkDestroySamplerYcbcrConversion,
        vkDestroySamplerYcbcrConversion,
        vkDestroySamplerYcbcrConversionUnsafe,
        vkDestroySamplerYcbcrConversionSafe, VkInternalAllocationType(..),
        VkSystemAllocationScope(..), newVkAllocationFunction,
        newVkDebugReportCallbackEXT, newVkDebugUtilsMessengerCallbackEXT,
        newVkFreeFunction, newVkInternalAllocationNotification,
        newVkInternalFreeNotification, newVkReallocationFunction,
        newVkVoidFunction, unwrapVkAllocationFunction,
        unwrapVkDebugReportCallbackEXT,
        unwrapVkDebugUtilsMessengerCallbackEXT, unwrapVkFreeFunction,
        unwrapVkInternalAllocationNotification,
        unwrapVkInternalFreeNotification, unwrapVkReallocationFunction,
        unwrapVkVoidFunction, HS_vkAllocationFunction,
        HS_vkDebugReportCallbackEXT, HS_vkDebugUtilsMessengerCallbackEXT,
        HS_vkFreeFunction, HS_vkInternalAllocationNotification,
        HS_vkInternalFreeNotification, HS_vkReallocationFunction,
        HS_vkVoidFunction, PFN_vkAllocationFunction,
        PFN_vkDebugReportCallbackEXT, PFN_vkDebugUtilsMessengerCallbackEXT,
        PFN_vkFreeFunction, PFN_vkInternalAllocationNotification,
        PFN_vkInternalFreeNotification, PFN_vkReallocationFunction,
        PFN_vkVoidFunction, VkAllocationCallbacks,
        VkSamplerCustomBorderColorCreateInfoEXT,
        VkSamplerReductionModeCreateInfo,
        VkSamplerReductionModeCreateInfoEXT,
        VkSamplerYcbcrConversionCreateInfoKHR,
        VkSamplerYcbcrConversionImageFormatPropertiesKHR,
        VkSamplerYcbcrConversionInfoKHR,
        pattern VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
        pattern VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
        pattern VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO,
        pattern VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
        pattern VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
        pattern VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
        pattern VK_FORMAT_G8B8G8R8_422_UNORM,
        pattern VK_FORMAT_B8G8R8G8_422_UNORM,
        pattern VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
        pattern VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
        pattern VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
        pattern VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
        pattern VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
        pattern VK_FORMAT_R10X6_UNORM_PACK16,
        pattern VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
        pattern VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
        pattern VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
        pattern VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
        pattern VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
        pattern VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
        pattern VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
        pattern VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
        pattern VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
        pattern VK_FORMAT_R12X4_UNORM_PACK16,
        pattern VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
        pattern VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
        pattern VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
        pattern VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
        pattern VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
        pattern VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
        pattern VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
        pattern VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
        pattern VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
        pattern VK_FORMAT_G16B16G16R16_422_UNORM,
        pattern VK_FORMAT_B16G16R16G16_422_UNORM,
        pattern VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
        pattern VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
        pattern VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
        pattern VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
        pattern VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,
        pattern VK_IMAGE_ASPECT_PLANE_0_BIT,
        pattern VK_IMAGE_ASPECT_PLANE_1_BIT,
        pattern VK_IMAGE_ASPECT_PLANE_2_BIT,
        pattern VK_IMAGE_CREATE_DISJOINT_BIT,
        pattern VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,
        pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
        pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,
        pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,
        pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT,
        pattern VK_FORMAT_FEATURE_DISJOINT_BIT,
        pattern VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
        -- ** Promoted from VK_KHR_descriptor_update_template
        VkDescriptorBindingBitmask(..), VkDescriptorPoolCreateBitmask(..),
        VkDescriptorType(..), VkDescriptorUpdateTemplateType(..),
        VkDescriptorBindingFlagBits(), VkDescriptorBindingFlagBitsEXT(..),
        VkDescriptorBindingFlags(), VkDescriptorPoolCreateFlagBits(),
        VkDescriptorPoolCreateFlags(),
        VkDescriptorSetLayoutCreateBitmask(..),
        VkDescriptorSetLayoutCreateFlagBits(),
        VkDescriptorSetLayoutCreateFlags(),
        VkDescriptorUpdateTemplateTypeKHR(..),
        VkDescriptorUpdateTemplateCreateInfo,
        VkDescriptorUpdateTemplateEntry, -- > #include "vk_platform.h"
                                         VkCreateDescriptorUpdateTemplate,
        pattern VkCreateDescriptorUpdateTemplate,
        HS_vkCreateDescriptorUpdateTemplate,
        PFN_vkCreateDescriptorUpdateTemplate,
        vkCreateDescriptorUpdateTemplate,
        vkCreateDescriptorUpdateTemplateUnsafe,
        vkCreateDescriptorUpdateTemplateSafe,
        VkDestroyDescriptorUpdateTemplate,
        pattern VkDestroyDescriptorUpdateTemplate,
        HS_vkDestroyDescriptorUpdateTemplate,
        PFN_vkDestroyDescriptorUpdateTemplate,
        vkDestroyDescriptorUpdateTemplate,
        vkDestroyDescriptorUpdateTemplateUnsafe,
        vkDestroyDescriptorUpdateTemplateSafe,
        VkUpdateDescriptorSetWithTemplate,
        pattern VkUpdateDescriptorSetWithTemplate,
        HS_vkUpdateDescriptorSetWithTemplate,
        PFN_vkUpdateDescriptorSetWithTemplate,
        vkUpdateDescriptorSetWithTemplate,
        vkUpdateDescriptorSetWithTemplateUnsafe,
        vkUpdateDescriptorSetWithTemplateSafe, VkDescriptorBufferInfo,
        VkDescriptorImageInfo, VkDescriptorPoolCreateInfo,
        VkDescriptorPoolInlineUniformBlockCreateInfoEXT,
        VkDescriptorPoolSize, VkDescriptorSetAllocateInfo,
        VkDescriptorSetLayoutBinding,
        VkDescriptorSetLayoutBindingFlagsCreateInfo,
        VkDescriptorSetLayoutBindingFlagsCreateInfoEXT,
        VkDescriptorSetLayoutCreateInfo, VkDescriptorSetLayoutSupport,
        VkDescriptorSetLayoutSupportKHR,
        VkDescriptorSetVariableDescriptorCountAllocateInfo,
        VkDescriptorSetVariableDescriptorCountAllocateInfoEXT,
        VkDescriptorSetVariableDescriptorCountLayoutSupport,
        VkDescriptorSetVariableDescriptorCountLayoutSupportEXT,
        VkDescriptorUpdateTemplateCreateInfoKHR,
        VkDescriptorUpdateTemplateEntryKHR,
        pattern VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
        pattern VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
        -- ** Promoted from VK_KHR_external_memory_capabilities
        VkBufferCreateBitmask(..), VkBufferUsageBitmask(..),
        VkBufferCreateFlagBits(), VkBufferCreateFlags(),
        VkBufferUsageFlagBits(), VkBufferUsageFlags(),
        VkExternalBufferProperties, VkExternalImageFormatProperties,
        VkExternalFenceFeatureBitmask(..),
        VkExternalFenceHandleTypeBitmask(..),
        VkExternalMemoryFeatureBitmask(..),
        VkExternalMemoryFeatureBitmaskNV(..),
        VkExternalMemoryHandleTypeBitmaskNV(..),
        VkExternalMemoryHandleTypeBitmask(..),
        VkExternalSemaphoreFeatureBitmask(..),
        VkExternalSemaphoreHandleTypeBitmask(..),
        VkExternalFenceFeatureFlagBits(),
        VkExternalFenceFeatureFlagBitsKHR(..),
        VkExternalFenceFeatureFlags(), VkExternalFenceHandleTypeFlagBits(),
        VkExternalFenceHandleTypeFlagBitsKHR(..),
        VkExternalFenceHandleTypeFlags(),
        VkExternalMemoryFeatureFlagBits(),
        VkExternalMemoryFeatureFlagBitsKHR(..),
        VkExternalMemoryFeatureFlagBitsNV(),
        VkExternalMemoryFeatureFlags(), VkExternalMemoryFeatureFlagsNV(),
        VkExternalMemoryHandleTypeFlagBits(),
        VkExternalMemoryHandleTypeFlagBitsKHR(..),
        VkExternalMemoryHandleTypeFlagBitsNV(),
        VkExternalMemoryHandleTypeFlags(),
        VkExternalMemoryHandleTypeFlagsNV(),
        VkExternalSemaphoreFeatureFlagBits(),
        VkExternalSemaphoreFeatureFlagBitsKHR(..),
        VkExternalSemaphoreFeatureFlags(),
        VkExternalSemaphoreHandleTypeFlagBits(),
        VkExternalSemaphoreHandleTypeFlagBitsKHR(..),
        VkExternalSemaphoreHandleTypeFlags(), VkExternalMemoryProperties,
        -- > #include "vk_platform.h"
        VkGetPhysicalDeviceExternalBufferProperties,
        pattern VkGetPhysicalDeviceExternalBufferProperties,
        HS_vkGetPhysicalDeviceExternalBufferProperties,
        PFN_vkGetPhysicalDeviceExternalBufferProperties,
        vkGetPhysicalDeviceExternalBufferProperties,
        vkGetPhysicalDeviceExternalBufferPropertiesUnsafe,
        vkGetPhysicalDeviceExternalBufferPropertiesSafe,
        VkExternalBufferPropertiesKHR, VkExternalFenceProperties,
        VkExternalFencePropertiesKHR, VkExternalImageFormatPropertiesKHR,
        VkExternalImageFormatPropertiesNV,
        VkExternalMemoryBufferCreateInfo,
        VkExternalMemoryBufferCreateInfoKHR,
        VkExternalMemoryImageCreateInfo,
        VkExternalMemoryImageCreateInfoKHR,
        VkExternalMemoryImageCreateInfoNV, VkExternalMemoryPropertiesKHR,
        VkExternalSemaphoreProperties, VkExternalSemaphorePropertiesKHR,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
        pattern VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
        pattern VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES,
        pattern VK_LUID_SIZE, VkExportMemoryAllocateInfo,
        VkSharingMode(..),
        -- > #include "vk_platform.h"
        pattern VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
        pattern VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
        pattern VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
        pattern VK_ERROR_INVALID_EXTERNAL_HANDLE,
        pattern VK_QUEUE_FAMILY_EXTERNAL,
        -- > #include "vk_platform.h"
        VkGetPhysicalDeviceExternalFenceProperties,
        pattern VkGetPhysicalDeviceExternalFenceProperties,
        HS_vkGetPhysicalDeviceExternalFenceProperties,
        PFN_vkGetPhysicalDeviceExternalFenceProperties,
        vkGetPhysicalDeviceExternalFenceProperties,
        vkGetPhysicalDeviceExternalFencePropertiesUnsafe,
        vkGetPhysicalDeviceExternalFencePropertiesSafe,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
        pattern VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
        -- ** Promoted from VK_KHR_external_fence
        VkExportFenceCreateInfo, VkFenceCreateBitmask(..),
        VkFenceImportBitmask(..), VkFenceCreateFlagBits(),
        VkFenceCreateFlags(), VkFenceImportFlagBits(),
        VkFenceImportFlagBitsKHR(..), VkFenceImportFlags(),
        VkFenceCreateInfo,
        -- > #include "vk_platform.h"
        pattern VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
        -- ** Promoted from VK_KHR_external_semaphore
        VkExportSemaphoreCreateInfo, VkSemaphoreCreateInfo,
        VkSemaphoreImportBitmask(..), VkSemaphoreType(..),
        VkSemaphoreWaitBitmask(..), VkSemaphoreImportFlagBits(),
        VkSemaphoreImportFlagBitsKHR(..), VkSemaphoreImportFlags(),
        VkSemaphoreTypeKHR(..), VkSemaphoreWaitFlagBits(),
        VkSemaphoreWaitFlagBitsKHR(..), VkSemaphoreWaitFlags(),
        -- > #include "vk_platform.h"
        pattern VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
        -- > #include "vk_platform.h"
        VkGetPhysicalDeviceExternalSemaphoreProperties,
        pattern VkGetPhysicalDeviceExternalSemaphoreProperties,
        HS_vkGetPhysicalDeviceExternalSemaphoreProperties,
        PFN_vkGetPhysicalDeviceExternalSemaphoreProperties,
        vkGetPhysicalDeviceExternalSemaphoreProperties,
        vkGetPhysicalDeviceExternalSemaphorePropertiesUnsafe,
        vkGetPhysicalDeviceExternalSemaphorePropertiesSafe,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
        pattern VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
        -- > #include "vk_platform.h"
        VkGetDescriptorSetLayoutSupport,
        pattern VkGetDescriptorSetLayoutSupport,
        HS_vkGetDescriptorSetLayoutSupport,
        PFN_vkGetDescriptorSetLayoutSupport,
        vkGetDescriptorSetLayoutSupport,
        vkGetDescriptorSetLayoutSupportUnsafe,
        vkGetDescriptorSetLayoutSupportSafe,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
        pattern VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT,
        -- > #include "vk_platform.h"
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
        pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES)
       where
import GHC.Ptr                                                     (Ptr (..))
import Graphics.Vulkan.Constants                                   (pattern VK_LUID_SIZE,
                                                                    pattern VK_MAX_DEVICE_GROUP_SIZE,
                                                                    pattern VK_QUEUE_FAMILY_EXTERNAL)
import Graphics.Vulkan.Marshal
import Graphics.Vulkan.Marshal.Proc
import Graphics.Vulkan.Types.BaseTypes
import Graphics.Vulkan.Types.Bitmasks
import Graphics.Vulkan.Types.Enum.AccessFlags
import Graphics.Vulkan.Types.Enum.Attachment
import Graphics.Vulkan.Types.Enum.BorderColor
import Graphics.Vulkan.Types.Enum.Buffer
import Graphics.Vulkan.Types.Enum.ChromaLocation
import Graphics.Vulkan.Types.Enum.Command
import Graphics.Vulkan.Types.Enum.CompareOp
import Graphics.Vulkan.Types.Enum.Component
import Graphics.Vulkan.Types.Enum.DependencyFlags
import Graphics.Vulkan.Types.Enum.Descriptor
import Graphics.Vulkan.Types.Enum.Device
import Graphics.Vulkan.Types.Enum.External
import Graphics.Vulkan.Types.Enum.Fence
import Graphics.Vulkan.Types.Enum.Filter
import Graphics.Vulkan.Types.Enum.Format
import Graphics.Vulkan.Types.Enum.Image
import Graphics.Vulkan.Types.Enum.InternalAllocationType
import Graphics.Vulkan.Types.Enum.Memory
import Graphics.Vulkan.Types.Enum.ObjectType                       (VkObjectType (..))
import Graphics.Vulkan.Types.Enum.PeerMemoryFeatureFlag
import Graphics.Vulkan.Types.Enum.PhysicalDeviceType
import Graphics.Vulkan.Types.Enum.Pipeline
import Graphics.Vulkan.Types.Enum.PointClippingBehavior
import Graphics.Vulkan.Types.Enum.Query
import Graphics.Vulkan.Types.Enum.Queue
import Graphics.Vulkan.Types.Enum.RenderPassCreateFlags
import Graphics.Vulkan.Types.Enum.Result
import Graphics.Vulkan.Types.Enum.SampleCountFlags
import Graphics.Vulkan.Types.Enum.Sampler
import Graphics.Vulkan.Types.Enum.Semaphore
import Graphics.Vulkan.Types.Enum.Shader
import Graphics.Vulkan.Types.Enum.SharingMode
import Graphics.Vulkan.Types.Enum.Sparse
import Graphics.Vulkan.Types.Enum.StructureType
import Graphics.Vulkan.Types.Enum.SubgroupFeatureFlags
import Graphics.Vulkan.Types.Enum.Subpass
import Graphics.Vulkan.Types.Enum.SystemAllocationScope
import Graphics.Vulkan.Types.Enum.TessellationDomainOrigin
import Graphics.Vulkan.Types.Funcpointers
import Graphics.Vulkan.Types.Handles
import Graphics.Vulkan.Types.Struct.AllocationCallbacks
import Graphics.Vulkan.Types.Struct.Attachment                     (VkAttachmentDescription,
                                                                    VkAttachmentReference)
import Graphics.Vulkan.Types.Struct.Bind
import Graphics.Vulkan.Types.Struct.Buffer
import Graphics.Vulkan.Types.Struct.Clear                          (VkClearColorValue,
                                                                    VkClearDepthStencilValue,
                                                                    VkClearValue)
import Graphics.Vulkan.Types.Struct.Command                        (VkCommandBufferBeginInfo,
                                                                    VkCommandBufferInheritanceInfo)
import Graphics.Vulkan.Types.Struct.ComponentMapping
import Graphics.Vulkan.Types.Struct.Descriptor
import Graphics.Vulkan.Types.Struct.Device
import Graphics.Vulkan.Types.Struct.Export                         (VkExportFenceCreateInfo,
                                                                    VkExportMemoryAllocateInfo,
                                                                    VkExportSemaphoreCreateInfo)
import Graphics.Vulkan.Types.Struct.Extent
import Graphics.Vulkan.Types.Struct.External
import Graphics.Vulkan.Types.Struct.Fence                          (VkFenceCreateInfo)
import Graphics.Vulkan.Types.Struct.FormatProperties
import Graphics.Vulkan.Types.Struct.Image
import Graphics.Vulkan.Types.Struct.InputAttachmentAspectReference (VkInputAttachmentAspectReference)
import Graphics.Vulkan.Types.Struct.Memory
import Graphics.Vulkan.Types.Struct.Offset                         (VkOffset2D,
                                                                    VkOffset3D)
import Graphics.Vulkan.Types.Struct.PhysicalDevice
import Graphics.Vulkan.Types.Struct.PhysicalDeviceFeatures
import Graphics.Vulkan.Types.Struct.Pipeline                       (VkPipelineTessellationDomainOriginStateCreateInfo,
                                                                    VkPipelineTessellationStateCreateInfo)
import Graphics.Vulkan.Types.Struct.ProtectedSubmitInfo            (VkProtectedSubmitInfo)
import Graphics.Vulkan.Types.Struct.QueueFamily
import Graphics.Vulkan.Types.Struct.Rect                           (VkRect2D)
import Graphics.Vulkan.Types.Struct.RenderPass                     (VkRenderPassBeginInfo,
                                                                    VkRenderPassCreateInfo,
                                                                    VkRenderPassInputAttachmentAspectCreateInfo,
                                                                    VkRenderPassMultiviewCreateInfo)
import Graphics.Vulkan.Types.Struct.Sampler
import Graphics.Vulkan.Types.Struct.Semaphore                      (VkSemaphoreCreateInfo)
import Graphics.Vulkan.Types.Struct.Sparse
import Graphics.Vulkan.Types.Struct.SubmitInfo                     (VkSubmitInfo)
import Graphics.Vulkan.Types.Struct.Subpass                        (VkSubpassDependency,
                                                                    VkSubpassDescription)
import System.IO.Unsafe                                            (unsafeDupablePerformIO)

pattern VkEnumerateInstanceVersion :: CString

pattern $bVkEnumerateInstanceVersion :: CString
$mVkEnumerateInstanceVersion :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkEnumerateInstanceVersion <-
        (is_VkEnumerateInstanceVersion -> True)
  where
    VkEnumerateInstanceVersion = CString
_VkEnumerateInstanceVersion

{-# INLINE _VkEnumerateInstanceVersion #-}

_VkEnumerateInstanceVersion :: CString
_VkEnumerateInstanceVersion :: CString
_VkEnumerateInstanceVersion = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkEnumerateInstanceVersion\NUL"#

{-# INLINE is_VkEnumerateInstanceVersion #-}

is_VkEnumerateInstanceVersion :: CString -> Bool
is_VkEnumerateInstanceVersion :: CString -> Bool
is_VkEnumerateInstanceVersion
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkEnumerateInstanceVersion

type VkEnumerateInstanceVersion = "vkEnumerateInstanceVersion"

-- |
-- Success codes: 'VK_SUCCESS'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY'.
--
-- > VkResult vkEnumerateInstanceVersion
-- >     ( uint32_t* pApiVersion
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateInstanceVersion vkEnumerateInstanceVersion registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myEnumerateInstanceVersion <- vkGetInstanceProc @VkEnumerateInstanceVersion vkInstance
--
-- or less efficient:
--
-- > myEnumerateInstanceVersion <- vkGetProc @VkEnumerateInstanceVersion
--
-- __Note:__ @vkEnumerateInstanceVersionUnsafe@ and @vkEnumerateInstanceVersionSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkEnumerateInstanceVersion@ is an alias
--           of @vkEnumerateInstanceVersionUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkEnumerateInstanceVersionSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkEnumerateInstanceVersion"
               vkEnumerateInstanceVersionUnsafe :: Ptr Word32 -- ^ pApiVersion
                                                              -> IO VkResult

#else
vkEnumerateInstanceVersionUnsafe :: Ptr Word32 -- ^ pApiVersion
                                               -> IO VkResult
vkEnumerateInstanceVersionUnsafe :: Ptr Word32 -> IO VkResult
vkEnumerateInstanceVersionUnsafe
  = IO (Ptr Word32 -> IO VkResult) -> Ptr Word32 -> IO VkResult
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkEnumerateInstanceVersion)

{-# NOINLINE vkEnumerateInstanceVersionUnsafe #-}
#endif

-- |
-- Success codes: 'VK_SUCCESS'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY'.
--
-- > VkResult vkEnumerateInstanceVersion
-- >     ( uint32_t* pApiVersion
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateInstanceVersion vkEnumerateInstanceVersion registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myEnumerateInstanceVersion <- vkGetInstanceProc @VkEnumerateInstanceVersion vkInstance
--
-- or less efficient:
--
-- > myEnumerateInstanceVersion <- vkGetProc @VkEnumerateInstanceVersion
--
-- __Note:__ @vkEnumerateInstanceVersionUnsafe@ and @vkEnumerateInstanceVersionSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkEnumerateInstanceVersion@ is an alias
--           of @vkEnumerateInstanceVersionUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkEnumerateInstanceVersionSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkEnumerateInstanceVersion"
               vkEnumerateInstanceVersionSafe :: Ptr Word32 -- ^ pApiVersion
                                                            -> IO VkResult

#else
vkEnumerateInstanceVersionSafe :: Ptr Word32 -- ^ pApiVersion
                                             -> IO VkResult
vkEnumerateInstanceVersionSafe :: Ptr Word32 -> IO VkResult
vkEnumerateInstanceVersionSafe
  = IO (Ptr Word32 -> IO VkResult) -> Ptr Word32 -> IO VkResult
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkEnumerateInstanceVersion)

{-# NOINLINE vkEnumerateInstanceVersionSafe #-}
#endif

-- |
-- Success codes: 'VK_SUCCESS'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY'.
--
-- > VkResult vkEnumerateInstanceVersion
-- >     ( uint32_t* pApiVersion
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateInstanceVersion vkEnumerateInstanceVersion registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myEnumerateInstanceVersion <- vkGetInstanceProc @VkEnumerateInstanceVersion vkInstance
--
-- or less efficient:
--
-- > myEnumerateInstanceVersion <- vkGetProc @VkEnumerateInstanceVersion
--
-- __Note:__ @vkEnumerateInstanceVersionUnsafe@ and @vkEnumerateInstanceVersionSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkEnumerateInstanceVersion@ is an alias
--           of @vkEnumerateInstanceVersionUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkEnumerateInstanceVersionSafe@.
--
vkEnumerateInstanceVersion :: Ptr Word32 -- ^ pApiVersion
                                         -> IO VkResult
#ifdef UNSAFE_FFI_DEFAULT
vkEnumerateInstanceVersion = vkEnumerateInstanceVersionUnsafe
#else
vkEnumerateInstanceVersion :: Ptr Word32 -> IO VkResult
vkEnumerateInstanceVersion = Ptr Word32 -> IO VkResult
vkEnumerateInstanceVersionSafe

#endif
{-# INLINE vkEnumerateInstanceVersion #-}

-- | Success codes: 'VK_SUCCESS'.
--
--   Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY'.
--
--   > VkResult vkEnumerateInstanceVersion
--   >     ( uint32_t* pApiVersion
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateInstanceVersion vkEnumerateInstanceVersion registry at www.khronos.org>
type HS_vkEnumerateInstanceVersion = Ptr Word32 -- ^ pApiVersion
                                                -> IO VkResult

type PFN_vkEnumerateInstanceVersion =
     FunPtr HS_vkEnumerateInstanceVersion

foreign import ccall unsafe "dynamic"
               unwrapVkEnumerateInstanceVersionUnsafe ::
               PFN_vkEnumerateInstanceVersion -> HS_vkEnumerateInstanceVersion

foreign import ccall safe "dynamic"
               unwrapVkEnumerateInstanceVersionSafe ::
               PFN_vkEnumerateInstanceVersion -> HS_vkEnumerateInstanceVersion

instance VulkanProc "vkEnumerateInstanceVersion" where
    type VkProcType "vkEnumerateInstanceVersion" =
         HS_vkEnumerateInstanceVersion
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkEnumerateInstanceVersion

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkEnumerateInstanceVersion)
-> VkProcType VkEnumerateInstanceVersion
unwrapVkProcPtrUnsafe = FunPtr (VkProcType VkEnumerateInstanceVersion)
-> VkProcType VkEnumerateInstanceVersion
PFN_vkEnumerateInstanceVersion -> Ptr Word32 -> IO VkResult
unwrapVkEnumerateInstanceVersionUnsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkEnumerateInstanceVersion)
-> VkProcType VkEnumerateInstanceVersion
unwrapVkProcPtrSafe = FunPtr (VkProcType VkEnumerateInstanceVersion)
-> VkProcType VkEnumerateInstanceVersion
PFN_vkEnumerateInstanceVersion -> Ptr Word32 -> IO VkResult
unwrapVkEnumerateInstanceVersionSafe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES =
        VkStructureType 1000094000

pattern VkBindBufferMemory2 :: CString

pattern $bVkBindBufferMemory2 :: CString
$mVkBindBufferMemory2 :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkBindBufferMemory2 <- (is_VkBindBufferMemory2 -> True)
  where
    VkBindBufferMemory2 = CString
_VkBindBufferMemory2

{-# INLINE _VkBindBufferMemory2 #-}

_VkBindBufferMemory2 :: CString
_VkBindBufferMemory2 :: CString
_VkBindBufferMemory2 = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkBindBufferMemory2\NUL"#

{-# INLINE is_VkBindBufferMemory2 #-}

is_VkBindBufferMemory2 :: CString -> Bool
is_VkBindBufferMemory2 :: CString -> Bool
is_VkBindBufferMemory2 = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkBindBufferMemory2

type VkBindBufferMemory2 = "vkBindBufferMemory2"

-- |
-- Success codes: 'VK_SUCCESS'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR'.
--
-- > VkResult vkBindBufferMemory2
-- >     ( VkDevice device
-- >     , uint32_t bindInfoCount
-- >     , const VkBindBufferMemoryInfo* pBindInfos
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBindBufferMemory2 vkBindBufferMemory2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myBindBufferMemory2 <- vkGetDeviceProc @VkBindBufferMemory2 vkDevice
--
-- or less efficient:
--
-- > myBindBufferMemory2 <- vkGetProc @VkBindBufferMemory2
--
-- __Note:__ @vkBindBufferMemory2Unsafe@ and @vkBindBufferMemory2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkBindBufferMemory2@ is an alias
--           of @vkBindBufferMemory2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkBindBufferMemory2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkBindBufferMemory2"
               vkBindBufferMemory2Unsafe ::
               VkDevice -- ^ device
                        -> Word32 -- ^ bindInfoCount
                                  -> Ptr VkBindBufferMemoryInfo -- ^ pBindInfos
                                                                -> IO VkResult

#else
vkBindBufferMemory2Unsafe ::
                          VkDevice -- ^ device
                                   -> Word32 -- ^ bindInfoCount
                                             -> Ptr VkBindBufferMemoryInfo -- ^ pBindInfos
                                                                           -> IO VkResult
vkBindBufferMemory2Unsafe :: VkDevice -> Word32 -> Ptr VkBindBufferMemoryInfo -> IO VkResult
vkBindBufferMemory2Unsafe
  = IO
  (VkDevice -> Word32 -> Ptr VkBindBufferMemoryInfo -> IO VkResult)
-> VkDevice -> Word32 -> Ptr VkBindBufferMemoryInfo -> IO VkResult
forall a. IO a -> a
unsafeDupablePerformIO (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkBindBufferMemory2)

{-# NOINLINE vkBindBufferMemory2Unsafe #-}
#endif

-- |
-- Success codes: 'VK_SUCCESS'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR'.
--
-- > VkResult vkBindBufferMemory2
-- >     ( VkDevice device
-- >     , uint32_t bindInfoCount
-- >     , const VkBindBufferMemoryInfo* pBindInfos
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBindBufferMemory2 vkBindBufferMemory2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myBindBufferMemory2 <- vkGetDeviceProc @VkBindBufferMemory2 vkDevice
--
-- or less efficient:
--
-- > myBindBufferMemory2 <- vkGetProc @VkBindBufferMemory2
--
-- __Note:__ @vkBindBufferMemory2Unsafe@ and @vkBindBufferMemory2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkBindBufferMemory2@ is an alias
--           of @vkBindBufferMemory2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkBindBufferMemory2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkBindBufferMemory2"
               vkBindBufferMemory2Safe ::
               VkDevice -- ^ device
                        -> Word32 -- ^ bindInfoCount
                                  -> Ptr VkBindBufferMemoryInfo -- ^ pBindInfos
                                                                -> IO VkResult

#else
vkBindBufferMemory2Safe ::
                        VkDevice -- ^ device
                                 -> Word32 -- ^ bindInfoCount
                                           -> Ptr VkBindBufferMemoryInfo -- ^ pBindInfos
                                                                         -> IO VkResult
vkBindBufferMemory2Safe :: VkDevice -> Word32 -> Ptr VkBindBufferMemoryInfo -> IO VkResult
vkBindBufferMemory2Safe
  = IO
  (VkDevice -> Word32 -> Ptr VkBindBufferMemoryInfo -> IO VkResult)
-> VkDevice -> Word32 -> Ptr VkBindBufferMemoryInfo -> IO VkResult
forall a. IO a -> a
unsafeDupablePerformIO (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkBindBufferMemory2)

{-# NOINLINE vkBindBufferMemory2Safe #-}
#endif

-- |
-- Success codes: 'VK_SUCCESS'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR'.
--
-- > VkResult vkBindBufferMemory2
-- >     ( VkDevice device
-- >     , uint32_t bindInfoCount
-- >     , const VkBindBufferMemoryInfo* pBindInfos
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBindBufferMemory2 vkBindBufferMemory2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myBindBufferMemory2 <- vkGetDeviceProc @VkBindBufferMemory2 vkDevice
--
-- or less efficient:
--
-- > myBindBufferMemory2 <- vkGetProc @VkBindBufferMemory2
--
-- __Note:__ @vkBindBufferMemory2Unsafe@ and @vkBindBufferMemory2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkBindBufferMemory2@ is an alias
--           of @vkBindBufferMemory2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkBindBufferMemory2Safe@.
--
vkBindBufferMemory2 ::
                    VkDevice -- ^ device
                             -> Word32 -- ^ bindInfoCount
                                       -> Ptr VkBindBufferMemoryInfo -- ^ pBindInfos
                                                                     -> IO VkResult
#ifdef UNSAFE_FFI_DEFAULT
vkBindBufferMemory2 = vkBindBufferMemory2Unsafe
#else
vkBindBufferMemory2 :: VkDevice -> Word32 -> Ptr VkBindBufferMemoryInfo -> IO VkResult
vkBindBufferMemory2 = VkDevice -> Word32 -> Ptr VkBindBufferMemoryInfo -> IO VkResult
vkBindBufferMemory2Safe

#endif
{-# INLINE vkBindBufferMemory2 #-}

-- | Success codes: 'VK_SUCCESS'.
--
--   Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR'.
--
--   > VkResult vkBindBufferMemory2
--   >     ( VkDevice device
--   >     , uint32_t bindInfoCount
--   >     , const VkBindBufferMemoryInfo* pBindInfos
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBindBufferMemory2 vkBindBufferMemory2 registry at www.khronos.org>
type HS_vkBindBufferMemory2 =
     VkDevice -- ^ device
              -> Word32 -- ^ bindInfoCount
                        -> Ptr VkBindBufferMemoryInfo -- ^ pBindInfos
                                                      -> IO VkResult

type PFN_vkBindBufferMemory2 = FunPtr HS_vkBindBufferMemory2

foreign import ccall unsafe "dynamic"
               unwrapVkBindBufferMemory2Unsafe ::
               PFN_vkBindBufferMemory2 -> HS_vkBindBufferMemory2

foreign import ccall safe "dynamic" unwrapVkBindBufferMemory2Safe
               :: PFN_vkBindBufferMemory2 -> HS_vkBindBufferMemory2

instance VulkanProc "vkBindBufferMemory2" where
    type VkProcType "vkBindBufferMemory2" = HS_vkBindBufferMemory2
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkBindBufferMemory2

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkBindBufferMemory2)
-> VkProcType VkBindBufferMemory2
unwrapVkProcPtrUnsafe = FunPtr (VkProcType VkBindBufferMemory2)
-> VkProcType VkBindBufferMemory2
PFN_vkBindBufferMemory2
-> VkDevice -> Word32 -> Ptr VkBindBufferMemoryInfo -> IO VkResult
unwrapVkBindBufferMemory2Unsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkBindBufferMemory2)
-> VkProcType VkBindBufferMemory2
unwrapVkProcPtrSafe = FunPtr (VkProcType VkBindBufferMemory2)
-> VkProcType VkBindBufferMemory2
PFN_vkBindBufferMemory2
-> VkDevice -> Word32 -> Ptr VkBindBufferMemoryInfo -> IO VkResult
unwrapVkBindBufferMemory2Safe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VkBindImageMemory2 :: CString

pattern $bVkBindImageMemory2 :: CString
$mVkBindImageMemory2 :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkBindImageMemory2 <- (is_VkBindImageMemory2 -> True)
  where
    VkBindImageMemory2 = CString
_VkBindImageMemory2

{-# INLINE _VkBindImageMemory2 #-}

_VkBindImageMemory2 :: CString
_VkBindImageMemory2 :: CString
_VkBindImageMemory2 = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkBindImageMemory2\NUL"#

{-# INLINE is_VkBindImageMemory2 #-}

is_VkBindImageMemory2 :: CString -> Bool
is_VkBindImageMemory2 :: CString -> Bool
is_VkBindImageMemory2 = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkBindImageMemory2

type VkBindImageMemory2 = "vkBindImageMemory2"

-- |
-- Success codes: 'VK_SUCCESS'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'.
--
-- > VkResult vkBindImageMemory2
-- >     ( VkDevice device
-- >     , uint32_t bindInfoCount
-- >     , const VkBindImageMemoryInfo* pBindInfos
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBindImageMemory2 vkBindImageMemory2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myBindImageMemory2 <- vkGetDeviceProc @VkBindImageMemory2 vkDevice
--
-- or less efficient:
--
-- > myBindImageMemory2 <- vkGetProc @VkBindImageMemory2
--
-- __Note:__ @vkBindImageMemory2Unsafe@ and @vkBindImageMemory2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkBindImageMemory2@ is an alias
--           of @vkBindImageMemory2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkBindImageMemory2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkBindImageMemory2"
               vkBindImageMemory2Unsafe ::
               VkDevice -- ^ device
                        -> Word32 -- ^ bindInfoCount
                                  -> Ptr VkBindImageMemoryInfo -- ^ pBindInfos
                                                               -> IO VkResult

#else
vkBindImageMemory2Unsafe ::
                         VkDevice -- ^ device
                                  -> Word32 -- ^ bindInfoCount
                                            -> Ptr VkBindImageMemoryInfo -- ^ pBindInfos
                                                                         -> IO VkResult
vkBindImageMemory2Unsafe :: VkDevice -> Word32 -> Ptr VkBindImageMemoryInfo -> IO VkResult
vkBindImageMemory2Unsafe
  = IO (VkDevice -> Word32 -> Ptr VkBindImageMemoryInfo -> IO VkResult)
-> VkDevice -> Word32 -> Ptr VkBindImageMemoryInfo -> IO VkResult
forall a. IO a -> a
unsafeDupablePerformIO (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkBindImageMemory2)

{-# NOINLINE vkBindImageMemory2Unsafe #-}
#endif

-- |
-- Success codes: 'VK_SUCCESS'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'.
--
-- > VkResult vkBindImageMemory2
-- >     ( VkDevice device
-- >     , uint32_t bindInfoCount
-- >     , const VkBindImageMemoryInfo* pBindInfos
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBindImageMemory2 vkBindImageMemory2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myBindImageMemory2 <- vkGetDeviceProc @VkBindImageMemory2 vkDevice
--
-- or less efficient:
--
-- > myBindImageMemory2 <- vkGetProc @VkBindImageMemory2
--
-- __Note:__ @vkBindImageMemory2Unsafe@ and @vkBindImageMemory2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkBindImageMemory2@ is an alias
--           of @vkBindImageMemory2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkBindImageMemory2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkBindImageMemory2"
               vkBindImageMemory2Safe ::
               VkDevice -- ^ device
                        -> Word32 -- ^ bindInfoCount
                                  -> Ptr VkBindImageMemoryInfo -- ^ pBindInfos
                                                               -> IO VkResult

#else
vkBindImageMemory2Safe ::
                       VkDevice -- ^ device
                                -> Word32 -- ^ bindInfoCount
                                          -> Ptr VkBindImageMemoryInfo -- ^ pBindInfos
                                                                       -> IO VkResult
vkBindImageMemory2Safe :: VkDevice -> Word32 -> Ptr VkBindImageMemoryInfo -> IO VkResult
vkBindImageMemory2Safe
  = IO (VkDevice -> Word32 -> Ptr VkBindImageMemoryInfo -> IO VkResult)
-> VkDevice -> Word32 -> Ptr VkBindImageMemoryInfo -> IO VkResult
forall a. IO a -> a
unsafeDupablePerformIO (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkBindImageMemory2)

{-# NOINLINE vkBindImageMemory2Safe #-}
#endif

-- |
-- Success codes: 'VK_SUCCESS'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'.
--
-- > VkResult vkBindImageMemory2
-- >     ( VkDevice device
-- >     , uint32_t bindInfoCount
-- >     , const VkBindImageMemoryInfo* pBindInfos
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBindImageMemory2 vkBindImageMemory2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myBindImageMemory2 <- vkGetDeviceProc @VkBindImageMemory2 vkDevice
--
-- or less efficient:
--
-- > myBindImageMemory2 <- vkGetProc @VkBindImageMemory2
--
-- __Note:__ @vkBindImageMemory2Unsafe@ and @vkBindImageMemory2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkBindImageMemory2@ is an alias
--           of @vkBindImageMemory2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkBindImageMemory2Safe@.
--
vkBindImageMemory2 ::
                   VkDevice -- ^ device
                            -> Word32 -- ^ bindInfoCount
                                      -> Ptr VkBindImageMemoryInfo -- ^ pBindInfos
                                                                   -> IO VkResult
#ifdef UNSAFE_FFI_DEFAULT
vkBindImageMemory2 = vkBindImageMemory2Unsafe
#else
vkBindImageMemory2 :: VkDevice -> Word32 -> Ptr VkBindImageMemoryInfo -> IO VkResult
vkBindImageMemory2 = VkDevice -> Word32 -> Ptr VkBindImageMemoryInfo -> IO VkResult
vkBindImageMemory2Safe

#endif
{-# INLINE vkBindImageMemory2 #-}

-- | Success codes: 'VK_SUCCESS'.
--
--   Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'.
--
--   > VkResult vkBindImageMemory2
--   >     ( VkDevice device
--   >     , uint32_t bindInfoCount
--   >     , const VkBindImageMemoryInfo* pBindInfos
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBindImageMemory2 vkBindImageMemory2 registry at www.khronos.org>
type HS_vkBindImageMemory2 =
     VkDevice -- ^ device
              -> Word32 -- ^ bindInfoCount
                        -> Ptr VkBindImageMemoryInfo -- ^ pBindInfos
                                                     -> IO VkResult

type PFN_vkBindImageMemory2 = FunPtr HS_vkBindImageMemory2

foreign import ccall unsafe "dynamic"
               unwrapVkBindImageMemory2Unsafe ::
               PFN_vkBindImageMemory2 -> HS_vkBindImageMemory2

foreign import ccall safe "dynamic" unwrapVkBindImageMemory2Safe ::
               PFN_vkBindImageMemory2 -> HS_vkBindImageMemory2

instance VulkanProc "vkBindImageMemory2" where
    type VkProcType "vkBindImageMemory2" = HS_vkBindImageMemory2
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkBindImageMemory2

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkBindImageMemory2)
-> VkProcType VkBindImageMemory2
unwrapVkProcPtrUnsafe = FunPtr (VkProcType VkBindImageMemory2)
-> VkProcType VkBindImageMemory2
PFN_vkBindImageMemory2
-> VkDevice -> Word32 -> Ptr VkBindImageMemoryInfo -> IO VkResult
unwrapVkBindImageMemory2Unsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkBindImageMemory2)
-> VkProcType VkBindImageMemory2
unwrapVkProcPtrSafe = FunPtr (VkProcType VkBindImageMemory2)
-> VkProcType VkBindImageMemory2
PFN_vkBindImageMemory2
-> VkDevice -> Word32 -> Ptr VkBindImageMemoryInfo -> IO VkResult
unwrapVkBindImageMemory2Safe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO =
        VkStructureType 1000157000

pattern VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO =
        VkStructureType 1000157001

-- | bitpos = @10@
pattern VK_IMAGE_CREATE_ALIAS_BIT :: VkImageCreateBitmask a

pattern $bVK_IMAGE_CREATE_ALIAS_BIT :: forall (a :: FlagType). VkImageCreateBitmask a
$mVK_IMAGE_CREATE_ALIAS_BIT :: forall {r} {a :: FlagType}.
VkImageCreateBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_IMAGE_CREATE_ALIAS_BIT = VkImageCreateBitmask 1024

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES =
        VkStructureType 1000083000

pattern VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS :: VkStructureType
$mVK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS =
        VkStructureType 1000127000

pattern VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO =
        VkStructureType 1000127001

pattern VkGetDeviceGroupPeerMemoryFeatures :: CString

pattern $bVkGetDeviceGroupPeerMemoryFeatures :: CString
$mVkGetDeviceGroupPeerMemoryFeatures :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkGetDeviceGroupPeerMemoryFeatures <-
        (is_VkGetDeviceGroupPeerMemoryFeatures -> True)
  where
    VkGetDeviceGroupPeerMemoryFeatures
      = CString
_VkGetDeviceGroupPeerMemoryFeatures

{-# INLINE _VkGetDeviceGroupPeerMemoryFeatures #-}

_VkGetDeviceGroupPeerMemoryFeatures :: CString
_VkGetDeviceGroupPeerMemoryFeatures :: CString
_VkGetDeviceGroupPeerMemoryFeatures
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkGetDeviceGroupPeerMemoryFeatures\NUL"#

{-# INLINE is_VkGetDeviceGroupPeerMemoryFeatures #-}

is_VkGetDeviceGroupPeerMemoryFeatures :: CString -> Bool
is_VkGetDeviceGroupPeerMemoryFeatures :: CString -> Bool
is_VkGetDeviceGroupPeerMemoryFeatures
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkGetDeviceGroupPeerMemoryFeatures

type VkGetDeviceGroupPeerMemoryFeatures =
     "vkGetDeviceGroupPeerMemoryFeatures"

-- |
-- > void vkGetDeviceGroupPeerMemoryFeatures
-- >     ( VkDevice device
-- >     , uint32_t heapIndex
-- >     , uint32_t localDeviceIndex
-- >     , uint32_t remoteDeviceIndex
-- >     , VkPeerMemoryFeatureFlags* pPeerMemoryFeatures
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetDeviceGroupPeerMemoryFeatures <- vkGetDeviceProc @VkGetDeviceGroupPeerMemoryFeatures vkDevice
--
-- or less efficient:
--
-- > myGetDeviceGroupPeerMemoryFeatures <- vkGetProc @VkGetDeviceGroupPeerMemoryFeatures
--
-- __Note:__ @vkGetDeviceGroupPeerMemoryFeaturesUnsafe@ and @vkGetDeviceGroupPeerMemoryFeaturesSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetDeviceGroupPeerMemoryFeatures@ is an alias
--           of @vkGetDeviceGroupPeerMemoryFeaturesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetDeviceGroupPeerMemoryFeaturesSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkGetDeviceGroupPeerMemoryFeatures"
               vkGetDeviceGroupPeerMemoryFeaturesUnsafe ::
               VkDevice -- ^ device
                        ->
                 Word32 -- ^ heapIndex
                        -> Word32 -- ^ localDeviceIndex
                                  -> Word32 -- ^ remoteDeviceIndex
                                            -> Ptr VkPeerMemoryFeatureFlags -- ^ pPeerMemoryFeatures
                                                                            -> IO ()

#else
vkGetDeviceGroupPeerMemoryFeaturesUnsafe ::
                                         VkDevice -- ^ device
                                                  ->
                                           Word32 -- ^ heapIndex
                                                  ->
                                             Word32 -- ^ localDeviceIndex
                                                    ->
                                               Word32 -- ^ remoteDeviceIndex
                                                      -> Ptr VkPeerMemoryFeatureFlags -- ^ pPeerMemoryFeatures
                                                                                      -> IO ()
vkGetDeviceGroupPeerMemoryFeaturesUnsafe :: VkDevice
-> Word32
-> Word32
-> Word32
-> Ptr VkPeerMemoryFeatureFlags
-> IO ()
vkGetDeviceGroupPeerMemoryFeaturesUnsafe
  = IO
  (VkDevice
   -> Word32
   -> Word32
   -> Word32
   -> Ptr VkPeerMemoryFeatureFlags
   -> IO ())
-> VkDevice
-> Word32
-> Word32
-> Word32
-> Ptr VkPeerMemoryFeatureFlags
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkGetDeviceGroupPeerMemoryFeatures)

{-# NOINLINE vkGetDeviceGroupPeerMemoryFeaturesUnsafe #-}
#endif

-- |
-- > void vkGetDeviceGroupPeerMemoryFeatures
-- >     ( VkDevice device
-- >     , uint32_t heapIndex
-- >     , uint32_t localDeviceIndex
-- >     , uint32_t remoteDeviceIndex
-- >     , VkPeerMemoryFeatureFlags* pPeerMemoryFeatures
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetDeviceGroupPeerMemoryFeatures <- vkGetDeviceProc @VkGetDeviceGroupPeerMemoryFeatures vkDevice
--
-- or less efficient:
--
-- > myGetDeviceGroupPeerMemoryFeatures <- vkGetProc @VkGetDeviceGroupPeerMemoryFeatures
--
-- __Note:__ @vkGetDeviceGroupPeerMemoryFeaturesUnsafe@ and @vkGetDeviceGroupPeerMemoryFeaturesSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetDeviceGroupPeerMemoryFeatures@ is an alias
--           of @vkGetDeviceGroupPeerMemoryFeaturesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetDeviceGroupPeerMemoryFeaturesSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkGetDeviceGroupPeerMemoryFeatures"
               vkGetDeviceGroupPeerMemoryFeaturesSafe ::
               VkDevice -- ^ device
                        ->
                 Word32 -- ^ heapIndex
                        -> Word32 -- ^ localDeviceIndex
                                  -> Word32 -- ^ remoteDeviceIndex
                                            -> Ptr VkPeerMemoryFeatureFlags -- ^ pPeerMemoryFeatures
                                                                            -> IO ()

#else
vkGetDeviceGroupPeerMemoryFeaturesSafe ::
                                       VkDevice -- ^ device
                                                ->
                                         Word32 -- ^ heapIndex
                                                ->
                                           Word32 -- ^ localDeviceIndex
                                                  -> Word32 -- ^ remoteDeviceIndex
                                                            -> Ptr VkPeerMemoryFeatureFlags -- ^ pPeerMemoryFeatures
                                                                                            -> IO ()
vkGetDeviceGroupPeerMemoryFeaturesSafe :: VkDevice
-> Word32
-> Word32
-> Word32
-> Ptr VkPeerMemoryFeatureFlags
-> IO ()
vkGetDeviceGroupPeerMemoryFeaturesSafe
  = IO
  (VkDevice
   -> Word32
   -> Word32
   -> Word32
   -> Ptr VkPeerMemoryFeatureFlags
   -> IO ())
-> VkDevice
-> Word32
-> Word32
-> Word32
-> Ptr VkPeerMemoryFeatureFlags
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkGetDeviceGroupPeerMemoryFeatures)

{-# NOINLINE vkGetDeviceGroupPeerMemoryFeaturesSafe #-}
#endif

-- |
-- > void vkGetDeviceGroupPeerMemoryFeatures
-- >     ( VkDevice device
-- >     , uint32_t heapIndex
-- >     , uint32_t localDeviceIndex
-- >     , uint32_t remoteDeviceIndex
-- >     , VkPeerMemoryFeatureFlags* pPeerMemoryFeatures
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetDeviceGroupPeerMemoryFeatures <- vkGetDeviceProc @VkGetDeviceGroupPeerMemoryFeatures vkDevice
--
-- or less efficient:
--
-- > myGetDeviceGroupPeerMemoryFeatures <- vkGetProc @VkGetDeviceGroupPeerMemoryFeatures
--
-- __Note:__ @vkGetDeviceGroupPeerMemoryFeaturesUnsafe@ and @vkGetDeviceGroupPeerMemoryFeaturesSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetDeviceGroupPeerMemoryFeatures@ is an alias
--           of @vkGetDeviceGroupPeerMemoryFeaturesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetDeviceGroupPeerMemoryFeaturesSafe@.
--
vkGetDeviceGroupPeerMemoryFeatures ::
                                   VkDevice -- ^ device
                                            ->
                                     Word32 -- ^ heapIndex
                                            ->
                                       Word32 -- ^ localDeviceIndex
                                              -> Word32 -- ^ remoteDeviceIndex
                                                        -> Ptr VkPeerMemoryFeatureFlags -- ^ pPeerMemoryFeatures
                                                                                        -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkGetDeviceGroupPeerMemoryFeatures
  = vkGetDeviceGroupPeerMemoryFeaturesUnsafe
#else
vkGetDeviceGroupPeerMemoryFeatures :: VkDevice
-> Word32
-> Word32
-> Word32
-> Ptr VkPeerMemoryFeatureFlags
-> IO ()
vkGetDeviceGroupPeerMemoryFeatures
  = VkDevice
-> Word32
-> Word32
-> Word32
-> Ptr VkPeerMemoryFeatureFlags
-> IO ()
vkGetDeviceGroupPeerMemoryFeaturesSafe

#endif
{-# INLINE vkGetDeviceGroupPeerMemoryFeatures #-}

-- | > void vkGetDeviceGroupPeerMemoryFeatures
--   >     ( VkDevice device
--   >     , uint32_t heapIndex
--   >     , uint32_t localDeviceIndex
--   >     , uint32_t remoteDeviceIndex
--   >     , VkPeerMemoryFeatureFlags* pPeerMemoryFeatures
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures registry at www.khronos.org>
type HS_vkGetDeviceGroupPeerMemoryFeatures =
     VkDevice -- ^ device
              ->
       Word32 -- ^ heapIndex
              -> Word32 -- ^ localDeviceIndex
                        -> Word32 -- ^ remoteDeviceIndex
                                  -> Ptr VkPeerMemoryFeatureFlags -- ^ pPeerMemoryFeatures
                                                                  -> IO ()

type PFN_vkGetDeviceGroupPeerMemoryFeatures =
     FunPtr HS_vkGetDeviceGroupPeerMemoryFeatures

foreign import ccall unsafe "dynamic"
               unwrapVkGetDeviceGroupPeerMemoryFeaturesUnsafe ::
               PFN_vkGetDeviceGroupPeerMemoryFeatures ->
                 HS_vkGetDeviceGroupPeerMemoryFeatures

foreign import ccall safe "dynamic"
               unwrapVkGetDeviceGroupPeerMemoryFeaturesSafe ::
               PFN_vkGetDeviceGroupPeerMemoryFeatures ->
                 HS_vkGetDeviceGroupPeerMemoryFeatures

instance VulkanProc "vkGetDeviceGroupPeerMemoryFeatures" where
    type VkProcType "vkGetDeviceGroupPeerMemoryFeatures" =
         HS_vkGetDeviceGroupPeerMemoryFeatures
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkGetDeviceGroupPeerMemoryFeatures

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkGetDeviceGroupPeerMemoryFeatures)
-> VkProcType VkGetDeviceGroupPeerMemoryFeatures
unwrapVkProcPtrUnsafe
      = FunPtr (VkProcType VkGetDeviceGroupPeerMemoryFeatures)
-> VkProcType VkGetDeviceGroupPeerMemoryFeatures
PFN_vkGetDeviceGroupPeerMemoryFeatures
-> VkDevice
-> Word32
-> Word32
-> Word32
-> Ptr VkPeerMemoryFeatureFlags
-> IO ()
unwrapVkGetDeviceGroupPeerMemoryFeaturesUnsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkGetDeviceGroupPeerMemoryFeatures)
-> VkProcType VkGetDeviceGroupPeerMemoryFeatures
unwrapVkProcPtrSafe = FunPtr (VkProcType VkGetDeviceGroupPeerMemoryFeatures)
-> VkProcType VkGetDeviceGroupPeerMemoryFeatures
PFN_vkGetDeviceGroupPeerMemoryFeatures
-> VkDevice
-> Word32
-> Word32
-> Word32
-> Ptr VkPeerMemoryFeatureFlags
-> IO ()
unwrapVkGetDeviceGroupPeerMemoryFeaturesSafe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VkCmdSetDeviceMask :: CString

pattern $bVkCmdSetDeviceMask :: CString
$mVkCmdSetDeviceMask :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkCmdSetDeviceMask <- (is_VkCmdSetDeviceMask -> True)
  where
    VkCmdSetDeviceMask = CString
_VkCmdSetDeviceMask

{-# INLINE _VkCmdSetDeviceMask #-}

_VkCmdSetDeviceMask :: CString
_VkCmdSetDeviceMask :: CString
_VkCmdSetDeviceMask = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkCmdSetDeviceMask\NUL"#

{-# INLINE is_VkCmdSetDeviceMask #-}

is_VkCmdSetDeviceMask :: CString -> Bool
is_VkCmdSetDeviceMask :: CString -> Bool
is_VkCmdSetDeviceMask = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkCmdSetDeviceMask

type VkCmdSetDeviceMask = "vkCmdSetDeviceMask"

-- |
-- Queues: 'graphics', 'compute', 'transfer'.
--
-- Renderpass: @both@
--
-- > void vkCmdSetDeviceMask
-- >     ( VkCommandBuffer commandBuffer
-- >     , uint32_t deviceMask
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetDeviceMask vkCmdSetDeviceMask registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myCmdSetDeviceMask <- vkGetInstanceProc @VkCmdSetDeviceMask vkInstance
--
-- or less efficient:
--
-- > myCmdSetDeviceMask <- vkGetProc @VkCmdSetDeviceMask
--
-- __Note:__ @vkCmdSetDeviceMaskUnsafe@ and @vkCmdSetDeviceMaskSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkCmdSetDeviceMask@ is an alias
--           of @vkCmdSetDeviceMaskUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkCmdSetDeviceMaskSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkCmdSetDeviceMask"
               vkCmdSetDeviceMaskUnsafe :: VkCommandBuffer -- ^ commandBuffer
                                                           -> Word32 -- ^ deviceMask
                                                                     -> IO ()

#else
vkCmdSetDeviceMaskUnsafe :: VkCommandBuffer -- ^ commandBuffer
                                            -> Word32 -- ^ deviceMask
                                                      -> IO ()
vkCmdSetDeviceMaskUnsafe :: VkCommandBuffer -> Word32 -> IO ()
vkCmdSetDeviceMaskUnsafe
  = IO (VkCommandBuffer -> Word32 -> IO ())
-> VkCommandBuffer -> Word32 -> IO ()
forall a. IO a -> a
unsafeDupablePerformIO (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkCmdSetDeviceMask)

{-# NOINLINE vkCmdSetDeviceMaskUnsafe #-}
#endif

-- |
-- Queues: 'graphics', 'compute', 'transfer'.
--
-- Renderpass: @both@
--
-- > void vkCmdSetDeviceMask
-- >     ( VkCommandBuffer commandBuffer
-- >     , uint32_t deviceMask
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetDeviceMask vkCmdSetDeviceMask registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myCmdSetDeviceMask <- vkGetInstanceProc @VkCmdSetDeviceMask vkInstance
--
-- or less efficient:
--
-- > myCmdSetDeviceMask <- vkGetProc @VkCmdSetDeviceMask
--
-- __Note:__ @vkCmdSetDeviceMaskUnsafe@ and @vkCmdSetDeviceMaskSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkCmdSetDeviceMask@ is an alias
--           of @vkCmdSetDeviceMaskUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkCmdSetDeviceMaskSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkCmdSetDeviceMask"
               vkCmdSetDeviceMaskSafe :: VkCommandBuffer -- ^ commandBuffer
                                                         -> Word32 -- ^ deviceMask
                                                                   -> IO ()

#else
vkCmdSetDeviceMaskSafe :: VkCommandBuffer -- ^ commandBuffer
                                          -> Word32 -- ^ deviceMask
                                                    -> IO ()
vkCmdSetDeviceMaskSafe :: VkCommandBuffer -> Word32 -> IO ()
vkCmdSetDeviceMaskSafe
  = IO (VkCommandBuffer -> Word32 -> IO ())
-> VkCommandBuffer -> Word32 -> IO ()
forall a. IO a -> a
unsafeDupablePerformIO (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkCmdSetDeviceMask)

{-# NOINLINE vkCmdSetDeviceMaskSafe #-}
#endif

-- |
-- Queues: 'graphics', 'compute', 'transfer'.
--
-- Renderpass: @both@
--
-- > void vkCmdSetDeviceMask
-- >     ( VkCommandBuffer commandBuffer
-- >     , uint32_t deviceMask
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetDeviceMask vkCmdSetDeviceMask registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myCmdSetDeviceMask <- vkGetInstanceProc @VkCmdSetDeviceMask vkInstance
--
-- or less efficient:
--
-- > myCmdSetDeviceMask <- vkGetProc @VkCmdSetDeviceMask
--
-- __Note:__ @vkCmdSetDeviceMaskUnsafe@ and @vkCmdSetDeviceMaskSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkCmdSetDeviceMask@ is an alias
--           of @vkCmdSetDeviceMaskUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkCmdSetDeviceMaskSafe@.
--
vkCmdSetDeviceMask :: VkCommandBuffer -- ^ commandBuffer
                                      -> Word32 -- ^ deviceMask
                                                -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkCmdSetDeviceMask = vkCmdSetDeviceMaskUnsafe
#else
vkCmdSetDeviceMask :: VkCommandBuffer -> Word32 -> IO ()
vkCmdSetDeviceMask = VkCommandBuffer -> Word32 -> IO ()
vkCmdSetDeviceMaskSafe

#endif
{-# INLINE vkCmdSetDeviceMask #-}

-- | Queues: 'graphics', 'compute', 'transfer'.
--
--   Renderpass: @both@
--
--   > void vkCmdSetDeviceMask
--   >     ( VkCommandBuffer commandBuffer
--   >     , uint32_t deviceMask
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetDeviceMask vkCmdSetDeviceMask registry at www.khronos.org>
type HS_vkCmdSetDeviceMask = VkCommandBuffer -- ^ commandBuffer
                                             -> Word32 -- ^ deviceMask
                                                       -> IO ()

type PFN_vkCmdSetDeviceMask = FunPtr HS_vkCmdSetDeviceMask

foreign import ccall unsafe "dynamic"
               unwrapVkCmdSetDeviceMaskUnsafe ::
               PFN_vkCmdSetDeviceMask -> HS_vkCmdSetDeviceMask

foreign import ccall safe "dynamic" unwrapVkCmdSetDeviceMaskSafe ::
               PFN_vkCmdSetDeviceMask -> HS_vkCmdSetDeviceMask

instance VulkanProc "vkCmdSetDeviceMask" where
    type VkProcType "vkCmdSetDeviceMask" = HS_vkCmdSetDeviceMask
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkCmdSetDeviceMask

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkCmdSetDeviceMask)
-> VkProcType VkCmdSetDeviceMask
unwrapVkProcPtrUnsafe = FunPtr (VkProcType VkCmdSetDeviceMask)
-> VkProcType VkCmdSetDeviceMask
PFN_vkCmdSetDeviceMask -> VkCommandBuffer -> Word32 -> IO ()
unwrapVkCmdSetDeviceMaskUnsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkCmdSetDeviceMask)
-> VkProcType VkCmdSetDeviceMask
unwrapVkProcPtrSafe = FunPtr (VkProcType VkCmdSetDeviceMask)
-> VkProcType VkCmdSetDeviceMask
PFN_vkCmdSetDeviceMask -> VkCommandBuffer -> Word32 -> IO ()
unwrapVkCmdSetDeviceMaskSafe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VkCmdDispatchBase :: CString

pattern $bVkCmdDispatchBase :: CString
$mVkCmdDispatchBase :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkCmdDispatchBase <- (is_VkCmdDispatchBase -> True)
  where
    VkCmdDispatchBase = CString
_VkCmdDispatchBase

{-# INLINE _VkCmdDispatchBase #-}

_VkCmdDispatchBase :: CString
_VkCmdDispatchBase :: CString
_VkCmdDispatchBase = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkCmdDispatchBase\NUL"#

{-# INLINE is_VkCmdDispatchBase #-}

is_VkCmdDispatchBase :: CString -> Bool
is_VkCmdDispatchBase :: CString -> Bool
is_VkCmdDispatchBase = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkCmdDispatchBase

type VkCmdDispatchBase = "vkCmdDispatchBase"

-- |
-- Queues: 'compute'.
--
-- Renderpass: @outside@
--
-- > void vkCmdDispatchBase
-- >     ( VkCommandBuffer commandBuffer
-- >     , uint32_t baseGroupX
-- >     , uint32_t baseGroupY
-- >     , uint32_t baseGroupZ
-- >     , uint32_t groupCountX
-- >     , uint32_t groupCountY
-- >     , uint32_t groupCountZ
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDispatchBase vkCmdDispatchBase registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myCmdDispatchBase <- vkGetInstanceProc @VkCmdDispatchBase vkInstance
--
-- or less efficient:
--
-- > myCmdDispatchBase <- vkGetProc @VkCmdDispatchBase
--
-- __Note:__ @vkCmdDispatchBaseUnsafe@ and @vkCmdDispatchBaseSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkCmdDispatchBase@ is an alias
--           of @vkCmdDispatchBaseUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkCmdDispatchBaseSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkCmdDispatchBase"
               vkCmdDispatchBaseUnsafe ::
               VkCommandBuffer -- ^ commandBuffer
                               ->
                 Word32 -- ^ baseGroupX
                        -> Word32 -- ^ baseGroupY
                                  -> Word32 -- ^ baseGroupZ
                                            -> Word32 -- ^ groupCountX
                                                      -> Word32 -- ^ groupCountY
                                                                -> Word32 -- ^ groupCountZ
                                                                          -> IO ()

#else
vkCmdDispatchBaseUnsafe ::
                        VkCommandBuffer -- ^ commandBuffer
                                        ->
                          Word32 -- ^ baseGroupX
                                 -> Word32 -- ^ baseGroupY
                                           -> Word32 -- ^ baseGroupZ
                                                     -> Word32 -- ^ groupCountX
                                                               -> Word32 -- ^ groupCountY
                                                                         -> Word32 -- ^ groupCountZ
                                                                                   -> IO ()
vkCmdDispatchBaseUnsafe :: VkCommandBuffer
-> Word32
-> Word32
-> Word32
-> Word32
-> Word32
-> Word32
-> IO ()
vkCmdDispatchBaseUnsafe
  = IO
  (VkCommandBuffer
   -> Word32
   -> Word32
   -> Word32
   -> Word32
   -> Word32
   -> Word32
   -> IO ())
-> VkCommandBuffer
-> Word32
-> Word32
-> Word32
-> Word32
-> Word32
-> Word32
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkCmdDispatchBase)

{-# NOINLINE vkCmdDispatchBaseUnsafe #-}
#endif

-- |
-- Queues: 'compute'.
--
-- Renderpass: @outside@
--
-- > void vkCmdDispatchBase
-- >     ( VkCommandBuffer commandBuffer
-- >     , uint32_t baseGroupX
-- >     , uint32_t baseGroupY
-- >     , uint32_t baseGroupZ
-- >     , uint32_t groupCountX
-- >     , uint32_t groupCountY
-- >     , uint32_t groupCountZ
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDispatchBase vkCmdDispatchBase registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myCmdDispatchBase <- vkGetInstanceProc @VkCmdDispatchBase vkInstance
--
-- or less efficient:
--
-- > myCmdDispatchBase <- vkGetProc @VkCmdDispatchBase
--
-- __Note:__ @vkCmdDispatchBaseUnsafe@ and @vkCmdDispatchBaseSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkCmdDispatchBase@ is an alias
--           of @vkCmdDispatchBaseUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkCmdDispatchBaseSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkCmdDispatchBase" vkCmdDispatchBaseSafe
               ::
               VkCommandBuffer -- ^ commandBuffer
                               ->
                 Word32 -- ^ baseGroupX
                        -> Word32 -- ^ baseGroupY
                                  -> Word32 -- ^ baseGroupZ
                                            -> Word32 -- ^ groupCountX
                                                      -> Word32 -- ^ groupCountY
                                                                -> Word32 -- ^ groupCountZ
                                                                          -> IO ()

#else
vkCmdDispatchBaseSafe ::
                      VkCommandBuffer -- ^ commandBuffer
                                      ->
                        Word32 -- ^ baseGroupX
                               -> Word32 -- ^ baseGroupY
                                         -> Word32 -- ^ baseGroupZ
                                                   -> Word32 -- ^ groupCountX
                                                             -> Word32 -- ^ groupCountY
                                                                       -> Word32 -- ^ groupCountZ
                                                                                 -> IO ()
vkCmdDispatchBaseSafe :: VkCommandBuffer
-> Word32
-> Word32
-> Word32
-> Word32
-> Word32
-> Word32
-> IO ()
vkCmdDispatchBaseSafe
  = IO
  (VkCommandBuffer
   -> Word32
   -> Word32
   -> Word32
   -> Word32
   -> Word32
   -> Word32
   -> IO ())
-> VkCommandBuffer
-> Word32
-> Word32
-> Word32
-> Word32
-> Word32
-> Word32
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkCmdDispatchBase)

{-# NOINLINE vkCmdDispatchBaseSafe #-}
#endif

-- |
-- Queues: 'compute'.
--
-- Renderpass: @outside@
--
-- > void vkCmdDispatchBase
-- >     ( VkCommandBuffer commandBuffer
-- >     , uint32_t baseGroupX
-- >     , uint32_t baseGroupY
-- >     , uint32_t baseGroupZ
-- >     , uint32_t groupCountX
-- >     , uint32_t groupCountY
-- >     , uint32_t groupCountZ
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDispatchBase vkCmdDispatchBase registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myCmdDispatchBase <- vkGetInstanceProc @VkCmdDispatchBase vkInstance
--
-- or less efficient:
--
-- > myCmdDispatchBase <- vkGetProc @VkCmdDispatchBase
--
-- __Note:__ @vkCmdDispatchBaseUnsafe@ and @vkCmdDispatchBaseSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkCmdDispatchBase@ is an alias
--           of @vkCmdDispatchBaseUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkCmdDispatchBaseSafe@.
--
vkCmdDispatchBase ::
                  VkCommandBuffer -- ^ commandBuffer
                                  ->
                    Word32 -- ^ baseGroupX
                           -> Word32 -- ^ baseGroupY
                                     -> Word32 -- ^ baseGroupZ
                                               -> Word32 -- ^ groupCountX
                                                         -> Word32 -- ^ groupCountY
                                                                   -> Word32 -- ^ groupCountZ
                                                                             -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkCmdDispatchBase = vkCmdDispatchBaseUnsafe
#else
vkCmdDispatchBase :: VkCommandBuffer
-> Word32
-> Word32
-> Word32
-> Word32
-> Word32
-> Word32
-> IO ()
vkCmdDispatchBase = VkCommandBuffer
-> Word32
-> Word32
-> Word32
-> Word32
-> Word32
-> Word32
-> IO ()
vkCmdDispatchBaseSafe

#endif
{-# INLINE vkCmdDispatchBase #-}

-- | Queues: 'compute'.
--
--   Renderpass: @outside@
--
--   > void vkCmdDispatchBase
--   >     ( VkCommandBuffer commandBuffer
--   >     , uint32_t baseGroupX
--   >     , uint32_t baseGroupY
--   >     , uint32_t baseGroupZ
--   >     , uint32_t groupCountX
--   >     , uint32_t groupCountY
--   >     , uint32_t groupCountZ
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDispatchBase vkCmdDispatchBase registry at www.khronos.org>
type HS_vkCmdDispatchBase =
     VkCommandBuffer -- ^ commandBuffer
                     ->
       Word32 -- ^ baseGroupX
              -> Word32 -- ^ baseGroupY
                        -> Word32 -- ^ baseGroupZ
                                  -> Word32 -- ^ groupCountX
                                            -> Word32 -- ^ groupCountY
                                                      -> Word32 -- ^ groupCountZ
                                                                -> IO ()

type PFN_vkCmdDispatchBase = FunPtr HS_vkCmdDispatchBase

foreign import ccall unsafe "dynamic" unwrapVkCmdDispatchBaseUnsafe
               :: PFN_vkCmdDispatchBase -> HS_vkCmdDispatchBase

foreign import ccall safe "dynamic" unwrapVkCmdDispatchBaseSafe ::
               PFN_vkCmdDispatchBase -> HS_vkCmdDispatchBase

instance VulkanProc "vkCmdDispatchBase" where
    type VkProcType "vkCmdDispatchBase" = HS_vkCmdDispatchBase
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkCmdDispatchBase

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkCmdDispatchBase)
-> VkProcType VkCmdDispatchBase
unwrapVkProcPtrUnsafe = FunPtr (VkProcType VkCmdDispatchBase)
-> VkProcType VkCmdDispatchBase
PFN_vkCmdDispatchBase
-> VkCommandBuffer
-> Word32
-> Word32
-> Word32
-> Word32
-> Word32
-> Word32
-> IO ()
unwrapVkCmdDispatchBaseUnsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkCmdDispatchBase)
-> VkProcType VkCmdDispatchBase
unwrapVkProcPtrSafe = FunPtr (VkProcType VkCmdDispatchBase)
-> VkProcType VkCmdDispatchBase
PFN_vkCmdDispatchBase
-> VkCommandBuffer
-> Word32
-> Word32
-> Word32
-> Word32
-> Word32
-> Word32
-> IO ()
unwrapVkCmdDispatchBaseSafe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO =
        VkStructureType 1000060000

pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO =
        VkStructureType 1000060003

pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO =
        VkStructureType 1000060004

pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO =
        VkStructureType 1000060005

pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO =
        VkStructureType 1000060006

-- | bitpos = @3@
pattern VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT ::
        VkPipelineCreateBitmask a

pattern $bVK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT :: forall (a :: FlagType). VkPipelineCreateBitmask a
$mVK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT :: forall {r} {a :: FlagType}.
VkPipelineCreateBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT =
        VkPipelineCreateBitmask 8

-- | bitpos = @4@
pattern VK_PIPELINE_CREATE_DISPATCH_BASE_BIT ::
        VkPipelineCreateBitmask a

pattern $bVK_PIPELINE_CREATE_DISPATCH_BASE_BIT :: forall (a :: FlagType). VkPipelineCreateBitmask a
$mVK_PIPELINE_CREATE_DISPATCH_BASE_BIT :: forall {r} {a :: FlagType}.
VkPipelineCreateBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_PIPELINE_CREATE_DISPATCH_BASE_BIT =
        VkPipelineCreateBitmask 16

pattern $bVK_PIPELINE_CREATE_DISPATCH_BASE :: forall (a :: FlagType). VkPipelineCreateBitmask a
$mVK_PIPELINE_CREATE_DISPATCH_BASE :: forall {r} {a :: FlagType}.
VkPipelineCreateBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_PIPELINE_CREATE_DISPATCH_BASE =
        VK_PIPELINE_CREATE_DISPATCH_BASE_BIT

-- | Dependency is across devices
--
--   bitpos = @2@
pattern VK_DEPENDENCY_DEVICE_GROUP_BIT :: VkDependencyBitmask a

pattern $bVK_DEPENDENCY_DEVICE_GROUP_BIT :: forall (a :: FlagType). VkDependencyBitmask a
$mVK_DEPENDENCY_DEVICE_GROUP_BIT :: forall {r} {a :: FlagType}.
VkDependencyBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_DEPENDENCY_DEVICE_GROUP_BIT = VkDependencyBitmask 4

pattern VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO =
        VkStructureType 1000060013

pattern VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO =
        VkStructureType 1000060014

-- | Allows using VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions when binding memory to the image
--
--   bitpos = @6@
pattern VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT ::
        VkImageCreateBitmask a

pattern $bVK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT :: forall (a :: FlagType). VkImageCreateBitmask a
$mVK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT :: forall {r} {a :: FlagType}.
VkImageCreateBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT =
        VkImageCreateBitmask 64

pattern VkEnumeratePhysicalDeviceGroups :: CString

pattern $bVkEnumeratePhysicalDeviceGroups :: CString
$mVkEnumeratePhysicalDeviceGroups :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkEnumeratePhysicalDeviceGroups <-
        (is_VkEnumeratePhysicalDeviceGroups -> True)
  where
    VkEnumeratePhysicalDeviceGroups = CString
_VkEnumeratePhysicalDeviceGroups

{-# INLINE _VkEnumeratePhysicalDeviceGroups #-}

_VkEnumeratePhysicalDeviceGroups :: CString
_VkEnumeratePhysicalDeviceGroups :: CString
_VkEnumeratePhysicalDeviceGroups
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkEnumeratePhysicalDeviceGroups\NUL"#

{-# INLINE is_VkEnumeratePhysicalDeviceGroups #-}

is_VkEnumeratePhysicalDeviceGroups :: CString -> Bool
is_VkEnumeratePhysicalDeviceGroups :: CString -> Bool
is_VkEnumeratePhysicalDeviceGroups
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkEnumeratePhysicalDeviceGroups

type VkEnumeratePhysicalDeviceGroups =
     "vkEnumeratePhysicalDeviceGroups"

-- |
-- Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INITIALIZATION_FAILED'.
--
-- > VkResult vkEnumeratePhysicalDeviceGroups
-- >     ( VkInstance instance
-- >     , uint32_t* pPhysicalDeviceGroupCount
-- >     , VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myEnumeratePhysicalDeviceGroups <- vkGetInstanceProc @VkEnumeratePhysicalDeviceGroups vkInstance
--
-- or less efficient:
--
-- > myEnumeratePhysicalDeviceGroups <- vkGetProc @VkEnumeratePhysicalDeviceGroups
--
-- __Note:__ @vkEnumeratePhysicalDeviceGroupsUnsafe@ and @vkEnumeratePhysicalDeviceGroupsSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkEnumeratePhysicalDeviceGroups@ is an alias
--           of @vkEnumeratePhysicalDeviceGroupsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkEnumeratePhysicalDeviceGroupsSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkEnumeratePhysicalDeviceGroups"
               vkEnumeratePhysicalDeviceGroupsUnsafe ::
               VkInstance -- ^ instance
                          ->
                 Ptr Word32 -- ^ pPhysicalDeviceGroupCount
                            -> Ptr VkPhysicalDeviceGroupProperties -- ^ pPhysicalDeviceGroupProperties
                                                                   -> IO VkResult

#else
vkEnumeratePhysicalDeviceGroupsUnsafe ::
                                      VkInstance -- ^ instance
                                                 ->
                                        Ptr Word32 -- ^ pPhysicalDeviceGroupCount
                                                   ->
                                          Ptr VkPhysicalDeviceGroupProperties -- ^ pPhysicalDeviceGroupProperties
                                                                              -> IO VkResult
vkEnumeratePhysicalDeviceGroupsUnsafe :: VkInstance
-> Ptr Word32 -> Ptr VkPhysicalDeviceGroupProperties -> IO VkResult
vkEnumeratePhysicalDeviceGroupsUnsafe
  = IO
  (VkInstance
   -> Ptr Word32
   -> Ptr VkPhysicalDeviceGroupProperties
   -> IO VkResult)
-> VkInstance
-> Ptr Word32
-> Ptr VkPhysicalDeviceGroupProperties
-> IO VkResult
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkEnumeratePhysicalDeviceGroups)

{-# NOINLINE vkEnumeratePhysicalDeviceGroupsUnsafe #-}
#endif

-- |
-- Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INITIALIZATION_FAILED'.
--
-- > VkResult vkEnumeratePhysicalDeviceGroups
-- >     ( VkInstance instance
-- >     , uint32_t* pPhysicalDeviceGroupCount
-- >     , VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myEnumeratePhysicalDeviceGroups <- vkGetInstanceProc @VkEnumeratePhysicalDeviceGroups vkInstance
--
-- or less efficient:
--
-- > myEnumeratePhysicalDeviceGroups <- vkGetProc @VkEnumeratePhysicalDeviceGroups
--
-- __Note:__ @vkEnumeratePhysicalDeviceGroupsUnsafe@ and @vkEnumeratePhysicalDeviceGroupsSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkEnumeratePhysicalDeviceGroups@ is an alias
--           of @vkEnumeratePhysicalDeviceGroupsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkEnumeratePhysicalDeviceGroupsSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkEnumeratePhysicalDeviceGroups"
               vkEnumeratePhysicalDeviceGroupsSafe ::
               VkInstance -- ^ instance
                          ->
                 Ptr Word32 -- ^ pPhysicalDeviceGroupCount
                            -> Ptr VkPhysicalDeviceGroupProperties -- ^ pPhysicalDeviceGroupProperties
                                                                   -> IO VkResult

#else
vkEnumeratePhysicalDeviceGroupsSafe ::
                                    VkInstance -- ^ instance
                                               ->
                                      Ptr Word32 -- ^ pPhysicalDeviceGroupCount
                                                 ->
                                        Ptr VkPhysicalDeviceGroupProperties -- ^ pPhysicalDeviceGroupProperties
                                                                            -> IO VkResult
vkEnumeratePhysicalDeviceGroupsSafe :: VkInstance
-> Ptr Word32 -> Ptr VkPhysicalDeviceGroupProperties -> IO VkResult
vkEnumeratePhysicalDeviceGroupsSafe
  = IO
  (VkInstance
   -> Ptr Word32
   -> Ptr VkPhysicalDeviceGroupProperties
   -> IO VkResult)
-> VkInstance
-> Ptr Word32
-> Ptr VkPhysicalDeviceGroupProperties
-> IO VkResult
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkEnumeratePhysicalDeviceGroups)

{-# NOINLINE vkEnumeratePhysicalDeviceGroupsSafe #-}
#endif

-- |
-- Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INITIALIZATION_FAILED'.
--
-- > VkResult vkEnumeratePhysicalDeviceGroups
-- >     ( VkInstance instance
-- >     , uint32_t* pPhysicalDeviceGroupCount
-- >     , VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myEnumeratePhysicalDeviceGroups <- vkGetInstanceProc @VkEnumeratePhysicalDeviceGroups vkInstance
--
-- or less efficient:
--
-- > myEnumeratePhysicalDeviceGroups <- vkGetProc @VkEnumeratePhysicalDeviceGroups
--
-- __Note:__ @vkEnumeratePhysicalDeviceGroupsUnsafe@ and @vkEnumeratePhysicalDeviceGroupsSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkEnumeratePhysicalDeviceGroups@ is an alias
--           of @vkEnumeratePhysicalDeviceGroupsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkEnumeratePhysicalDeviceGroupsSafe@.
--
vkEnumeratePhysicalDeviceGroups ::
                                VkInstance -- ^ instance
                                           ->
                                  Ptr Word32 -- ^ pPhysicalDeviceGroupCount
                                             -> Ptr VkPhysicalDeviceGroupProperties -- ^ pPhysicalDeviceGroupProperties
                                                                                    -> IO VkResult
#ifdef UNSAFE_FFI_DEFAULT
vkEnumeratePhysicalDeviceGroups
  = vkEnumeratePhysicalDeviceGroupsUnsafe
#else
vkEnumeratePhysicalDeviceGroups :: VkInstance
-> Ptr Word32 -> Ptr VkPhysicalDeviceGroupProperties -> IO VkResult
vkEnumeratePhysicalDeviceGroups
  = VkInstance
-> Ptr Word32 -> Ptr VkPhysicalDeviceGroupProperties -> IO VkResult
vkEnumeratePhysicalDeviceGroupsSafe

#endif
{-# INLINE vkEnumeratePhysicalDeviceGroups #-}

-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'.
--
--   Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INITIALIZATION_FAILED'.
--
--   > VkResult vkEnumeratePhysicalDeviceGroups
--   >     ( VkInstance instance
--   >     , uint32_t* pPhysicalDeviceGroupCount
--   >     , VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups registry at www.khronos.org>
type HS_vkEnumeratePhysicalDeviceGroups =
     VkInstance -- ^ instance
                ->
       Ptr Word32 -- ^ pPhysicalDeviceGroupCount
                  -> Ptr VkPhysicalDeviceGroupProperties -- ^ pPhysicalDeviceGroupProperties
                                                         -> IO VkResult

type PFN_vkEnumeratePhysicalDeviceGroups =
     FunPtr HS_vkEnumeratePhysicalDeviceGroups

foreign import ccall unsafe "dynamic"
               unwrapVkEnumeratePhysicalDeviceGroupsUnsafe ::
               PFN_vkEnumeratePhysicalDeviceGroups ->
                 HS_vkEnumeratePhysicalDeviceGroups

foreign import ccall safe "dynamic"
               unwrapVkEnumeratePhysicalDeviceGroupsSafe ::
               PFN_vkEnumeratePhysicalDeviceGroups ->
                 HS_vkEnumeratePhysicalDeviceGroups

instance VulkanProc "vkEnumeratePhysicalDeviceGroups" where
    type VkProcType "vkEnumeratePhysicalDeviceGroups" =
         HS_vkEnumeratePhysicalDeviceGroups
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkEnumeratePhysicalDeviceGroups

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkEnumeratePhysicalDeviceGroups)
-> VkProcType VkEnumeratePhysicalDeviceGroups
unwrapVkProcPtrUnsafe = FunPtr (VkProcType VkEnumeratePhysicalDeviceGroups)
-> VkProcType VkEnumeratePhysicalDeviceGroups
PFN_vkEnumeratePhysicalDeviceGroups
-> VkInstance
-> Ptr Word32
-> Ptr VkPhysicalDeviceGroupProperties
-> IO VkResult
unwrapVkEnumeratePhysicalDeviceGroupsUnsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkEnumeratePhysicalDeviceGroups)
-> VkProcType VkEnumeratePhysicalDeviceGroups
unwrapVkProcPtrSafe = FunPtr (VkProcType VkEnumeratePhysicalDeviceGroups)
-> VkProcType VkEnumeratePhysicalDeviceGroups
PFN_vkEnumeratePhysicalDeviceGroups
-> VkInstance
-> Ptr Word32
-> Ptr VkPhysicalDeviceGroupProperties
-> IO VkResult
unwrapVkEnumeratePhysicalDeviceGroupsSafe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES =
        VkStructureType 1000070000

pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO =
        VkStructureType 1000070001

-- | If set, heap allocations allocate multiple instances by default
--
--   bitpos = @1@
pattern VK_MEMORY_HEAP_MULTI_INSTANCE_BIT :: VkMemoryHeapBitmask a

pattern $bVK_MEMORY_HEAP_MULTI_INSTANCE_BIT :: forall (a :: FlagType). VkMemoryHeapBitmask a
$mVK_MEMORY_HEAP_MULTI_INSTANCE_BIT :: forall {r} {a :: FlagType}.
VkMemoryHeapBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = VkMemoryHeapBitmask 2

pattern VkGetImageMemoryRequirements2 :: CString

pattern $bVkGetImageMemoryRequirements2 :: CString
$mVkGetImageMemoryRequirements2 :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkGetImageMemoryRequirements2 <-
        (is_VkGetImageMemoryRequirements2 -> True)
  where
    VkGetImageMemoryRequirements2 = CString
_VkGetImageMemoryRequirements2

{-# INLINE _VkGetImageMemoryRequirements2 #-}

_VkGetImageMemoryRequirements2 :: CString
_VkGetImageMemoryRequirements2 :: CString
_VkGetImageMemoryRequirements2
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkGetImageMemoryRequirements2\NUL"#

{-# INLINE is_VkGetImageMemoryRequirements2 #-}

is_VkGetImageMemoryRequirements2 :: CString -> Bool
is_VkGetImageMemoryRequirements2 :: CString -> Bool
is_VkGetImageMemoryRequirements2
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkGetImageMemoryRequirements2

type VkGetImageMemoryRequirements2 =
     "vkGetImageMemoryRequirements2"

-- |
-- > void vkGetImageMemoryRequirements2
-- >     ( VkDevice device
-- >     , const VkImageMemoryRequirementsInfo2* pInfo
-- >     , VkMemoryRequirements2* pMemoryRequirements
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetImageMemoryRequirements2 <- vkGetDeviceProc @VkGetImageMemoryRequirements2 vkDevice
--
-- or less efficient:
--
-- > myGetImageMemoryRequirements2 <- vkGetProc @VkGetImageMemoryRequirements2
--
-- __Note:__ @vkGetImageMemoryRequirements2Unsafe@ and @vkGetImageMemoryRequirements2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetImageMemoryRequirements2@ is an alias
--           of @vkGetImageMemoryRequirements2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetImageMemoryRequirements2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkGetImageMemoryRequirements2"
               vkGetImageMemoryRequirements2Unsafe ::
               VkDevice -- ^ device
                        ->
                 Ptr VkImageMemoryRequirementsInfo2 -- ^ pInfo
                                                    ->
                   Ptr VkMemoryRequirements2 -- ^ pMemoryRequirements
                                             -> IO ()

#else
vkGetImageMemoryRequirements2Unsafe ::
                                    VkDevice -- ^ device
                                             ->
                                      Ptr VkImageMemoryRequirementsInfo2 -- ^ pInfo
                                                                         ->
                                        Ptr VkMemoryRequirements2 -- ^ pMemoryRequirements
                                                                  -> IO ()
vkGetImageMemoryRequirements2Unsafe :: VkDevice
-> Ptr VkImageMemoryRequirementsInfo2
-> Ptr VkMemoryRequirements2
-> IO ()
vkGetImageMemoryRequirements2Unsafe
  = IO
  (VkDevice
   -> Ptr VkImageMemoryRequirementsInfo2
   -> Ptr VkMemoryRequirements2
   -> IO ())
-> VkDevice
-> Ptr VkImageMemoryRequirementsInfo2
-> Ptr VkMemoryRequirements2
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkGetImageMemoryRequirements2)

{-# NOINLINE vkGetImageMemoryRequirements2Unsafe #-}
#endif

-- |
-- > void vkGetImageMemoryRequirements2
-- >     ( VkDevice device
-- >     , const VkImageMemoryRequirementsInfo2* pInfo
-- >     , VkMemoryRequirements2* pMemoryRequirements
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetImageMemoryRequirements2 <- vkGetDeviceProc @VkGetImageMemoryRequirements2 vkDevice
--
-- or less efficient:
--
-- > myGetImageMemoryRequirements2 <- vkGetProc @VkGetImageMemoryRequirements2
--
-- __Note:__ @vkGetImageMemoryRequirements2Unsafe@ and @vkGetImageMemoryRequirements2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetImageMemoryRequirements2@ is an alias
--           of @vkGetImageMemoryRequirements2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetImageMemoryRequirements2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkGetImageMemoryRequirements2"
               vkGetImageMemoryRequirements2Safe ::
               VkDevice -- ^ device
                        ->
                 Ptr VkImageMemoryRequirementsInfo2 -- ^ pInfo
                                                    ->
                   Ptr VkMemoryRequirements2 -- ^ pMemoryRequirements
                                             -> IO ()

#else
vkGetImageMemoryRequirements2Safe ::
                                  VkDevice -- ^ device
                                           ->
                                    Ptr VkImageMemoryRequirementsInfo2 -- ^ pInfo
                                                                       ->
                                      Ptr VkMemoryRequirements2 -- ^ pMemoryRequirements
                                                                -> IO ()
vkGetImageMemoryRequirements2Safe :: VkDevice
-> Ptr VkImageMemoryRequirementsInfo2
-> Ptr VkMemoryRequirements2
-> IO ()
vkGetImageMemoryRequirements2Safe
  = IO
  (VkDevice
   -> Ptr VkImageMemoryRequirementsInfo2
   -> Ptr VkMemoryRequirements2
   -> IO ())
-> VkDevice
-> Ptr VkImageMemoryRequirementsInfo2
-> Ptr VkMemoryRequirements2
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkGetImageMemoryRequirements2)

{-# NOINLINE vkGetImageMemoryRequirements2Safe #-}
#endif

-- |
-- > void vkGetImageMemoryRequirements2
-- >     ( VkDevice device
-- >     , const VkImageMemoryRequirementsInfo2* pInfo
-- >     , VkMemoryRequirements2* pMemoryRequirements
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetImageMemoryRequirements2 <- vkGetDeviceProc @VkGetImageMemoryRequirements2 vkDevice
--
-- or less efficient:
--
-- > myGetImageMemoryRequirements2 <- vkGetProc @VkGetImageMemoryRequirements2
--
-- __Note:__ @vkGetImageMemoryRequirements2Unsafe@ and @vkGetImageMemoryRequirements2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetImageMemoryRequirements2@ is an alias
--           of @vkGetImageMemoryRequirements2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetImageMemoryRequirements2Safe@.
--
vkGetImageMemoryRequirements2 ::
                              VkDevice -- ^ device
                                       ->
                                Ptr VkImageMemoryRequirementsInfo2 -- ^ pInfo
                                                                   ->
                                  Ptr VkMemoryRequirements2 -- ^ pMemoryRequirements
                                                            -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2Unsafe
#else
vkGetImageMemoryRequirements2 :: VkDevice
-> Ptr VkImageMemoryRequirementsInfo2
-> Ptr VkMemoryRequirements2
-> IO ()
vkGetImageMemoryRequirements2 = VkDevice
-> Ptr VkImageMemoryRequirementsInfo2
-> Ptr VkMemoryRequirements2
-> IO ()
vkGetImageMemoryRequirements2Safe

#endif
{-# INLINE vkGetImageMemoryRequirements2 #-}

-- | > void vkGetImageMemoryRequirements2
--   >     ( VkDevice device
--   >     , const VkImageMemoryRequirementsInfo2* pInfo
--   >     , VkMemoryRequirements2* pMemoryRequirements
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 registry at www.khronos.org>
type HS_vkGetImageMemoryRequirements2 =
     VkDevice -- ^ device
              ->
       Ptr VkImageMemoryRequirementsInfo2 -- ^ pInfo
                                          ->
         Ptr VkMemoryRequirements2 -- ^ pMemoryRequirements
                                   -> IO ()

type PFN_vkGetImageMemoryRequirements2 =
     FunPtr HS_vkGetImageMemoryRequirements2

foreign import ccall unsafe "dynamic"
               unwrapVkGetImageMemoryRequirements2Unsafe ::
               PFN_vkGetImageMemoryRequirements2 ->
                 HS_vkGetImageMemoryRequirements2

foreign import ccall safe "dynamic"
               unwrapVkGetImageMemoryRequirements2Safe ::
               PFN_vkGetImageMemoryRequirements2 ->
                 HS_vkGetImageMemoryRequirements2

instance VulkanProc "vkGetImageMemoryRequirements2" where
    type VkProcType "vkGetImageMemoryRequirements2" =
         HS_vkGetImageMemoryRequirements2
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkGetImageMemoryRequirements2

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkGetImageMemoryRequirements2)
-> VkProcType VkGetImageMemoryRequirements2
unwrapVkProcPtrUnsafe = FunPtr (VkProcType VkGetImageMemoryRequirements2)
-> VkProcType VkGetImageMemoryRequirements2
PFN_vkGetImageMemoryRequirements2
-> VkDevice
-> Ptr VkImageMemoryRequirementsInfo2
-> Ptr VkMemoryRequirements2
-> IO ()
unwrapVkGetImageMemoryRequirements2Unsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkGetImageMemoryRequirements2)
-> VkProcType VkGetImageMemoryRequirements2
unwrapVkProcPtrSafe = FunPtr (VkProcType VkGetImageMemoryRequirements2)
-> VkProcType VkGetImageMemoryRequirements2
PFN_vkGetImageMemoryRequirements2
-> VkDevice
-> Ptr VkImageMemoryRequirementsInfo2
-> Ptr VkMemoryRequirements2
-> IO ()
unwrapVkGetImageMemoryRequirements2Safe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VkGetBufferMemoryRequirements2 :: CString

pattern $bVkGetBufferMemoryRequirements2 :: CString
$mVkGetBufferMemoryRequirements2 :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkGetBufferMemoryRequirements2 <-
        (is_VkGetBufferMemoryRequirements2 -> True)
  where
    VkGetBufferMemoryRequirements2 = CString
_VkGetBufferMemoryRequirements2

{-# INLINE _VkGetBufferMemoryRequirements2 #-}

_VkGetBufferMemoryRequirements2 :: CString
_VkGetBufferMemoryRequirements2 :: CString
_VkGetBufferMemoryRequirements2
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkGetBufferMemoryRequirements2\NUL"#

{-# INLINE is_VkGetBufferMemoryRequirements2 #-}

is_VkGetBufferMemoryRequirements2 :: CString -> Bool
is_VkGetBufferMemoryRequirements2 :: CString -> Bool
is_VkGetBufferMemoryRequirements2
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkGetBufferMemoryRequirements2

type VkGetBufferMemoryRequirements2 =
     "vkGetBufferMemoryRequirements2"

-- |
-- > void vkGetBufferMemoryRequirements2
-- >     ( VkDevice device
-- >     , const VkBufferMemoryRequirementsInfo2* pInfo
-- >     , VkMemoryRequirements2* pMemoryRequirements
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetBufferMemoryRequirements2 <- vkGetDeviceProc @VkGetBufferMemoryRequirements2 vkDevice
--
-- or less efficient:
--
-- > myGetBufferMemoryRequirements2 <- vkGetProc @VkGetBufferMemoryRequirements2
--
-- __Note:__ @vkGetBufferMemoryRequirements2Unsafe@ and @vkGetBufferMemoryRequirements2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetBufferMemoryRequirements2@ is an alias
--           of @vkGetBufferMemoryRequirements2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetBufferMemoryRequirements2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkGetBufferMemoryRequirements2"
               vkGetBufferMemoryRequirements2Unsafe ::
               VkDevice -- ^ device
                        ->
                 Ptr VkBufferMemoryRequirementsInfo2 -- ^ pInfo
                                                     ->
                   Ptr VkMemoryRequirements2 -- ^ pMemoryRequirements
                                             -> IO ()

#else
vkGetBufferMemoryRequirements2Unsafe ::
                                     VkDevice -- ^ device
                                              ->
                                       Ptr VkBufferMemoryRequirementsInfo2 -- ^ pInfo
                                                                           ->
                                         Ptr VkMemoryRequirements2 -- ^ pMemoryRequirements
                                                                   -> IO ()
vkGetBufferMemoryRequirements2Unsafe :: VkDevice
-> Ptr VkBufferMemoryRequirementsInfo2
-> Ptr VkMemoryRequirements2
-> IO ()
vkGetBufferMemoryRequirements2Unsafe
  = IO
  (VkDevice
   -> Ptr VkBufferMemoryRequirementsInfo2
   -> Ptr VkMemoryRequirements2
   -> IO ())
-> VkDevice
-> Ptr VkBufferMemoryRequirementsInfo2
-> Ptr VkMemoryRequirements2
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkGetBufferMemoryRequirements2)

{-# NOINLINE vkGetBufferMemoryRequirements2Unsafe #-}
#endif

-- |
-- > void vkGetBufferMemoryRequirements2
-- >     ( VkDevice device
-- >     , const VkBufferMemoryRequirementsInfo2* pInfo
-- >     , VkMemoryRequirements2* pMemoryRequirements
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetBufferMemoryRequirements2 <- vkGetDeviceProc @VkGetBufferMemoryRequirements2 vkDevice
--
-- or less efficient:
--
-- > myGetBufferMemoryRequirements2 <- vkGetProc @VkGetBufferMemoryRequirements2
--
-- __Note:__ @vkGetBufferMemoryRequirements2Unsafe@ and @vkGetBufferMemoryRequirements2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetBufferMemoryRequirements2@ is an alias
--           of @vkGetBufferMemoryRequirements2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetBufferMemoryRequirements2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkGetBufferMemoryRequirements2"
               vkGetBufferMemoryRequirements2Safe ::
               VkDevice -- ^ device
                        ->
                 Ptr VkBufferMemoryRequirementsInfo2 -- ^ pInfo
                                                     ->
                   Ptr VkMemoryRequirements2 -- ^ pMemoryRequirements
                                             -> IO ()

#else
vkGetBufferMemoryRequirements2Safe ::
                                   VkDevice -- ^ device
                                            ->
                                     Ptr VkBufferMemoryRequirementsInfo2 -- ^ pInfo
                                                                         ->
                                       Ptr VkMemoryRequirements2 -- ^ pMemoryRequirements
                                                                 -> IO ()
vkGetBufferMemoryRequirements2Safe :: VkDevice
-> Ptr VkBufferMemoryRequirementsInfo2
-> Ptr VkMemoryRequirements2
-> IO ()
vkGetBufferMemoryRequirements2Safe
  = IO
  (VkDevice
   -> Ptr VkBufferMemoryRequirementsInfo2
   -> Ptr VkMemoryRequirements2
   -> IO ())
-> VkDevice
-> Ptr VkBufferMemoryRequirementsInfo2
-> Ptr VkMemoryRequirements2
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkGetBufferMemoryRequirements2)

{-# NOINLINE vkGetBufferMemoryRequirements2Safe #-}
#endif

-- |
-- > void vkGetBufferMemoryRequirements2
-- >     ( VkDevice device
-- >     , const VkBufferMemoryRequirementsInfo2* pInfo
-- >     , VkMemoryRequirements2* pMemoryRequirements
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetBufferMemoryRequirements2 <- vkGetDeviceProc @VkGetBufferMemoryRequirements2 vkDevice
--
-- or less efficient:
--
-- > myGetBufferMemoryRequirements2 <- vkGetProc @VkGetBufferMemoryRequirements2
--
-- __Note:__ @vkGetBufferMemoryRequirements2Unsafe@ and @vkGetBufferMemoryRequirements2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetBufferMemoryRequirements2@ is an alias
--           of @vkGetBufferMemoryRequirements2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetBufferMemoryRequirements2Safe@.
--
vkGetBufferMemoryRequirements2 ::
                               VkDevice -- ^ device
                                        ->
                                 Ptr VkBufferMemoryRequirementsInfo2 -- ^ pInfo
                                                                     ->
                                   Ptr VkMemoryRequirements2 -- ^ pMemoryRequirements
                                                             -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkGetBufferMemoryRequirements2
  = vkGetBufferMemoryRequirements2Unsafe
#else
vkGetBufferMemoryRequirements2 :: VkDevice
-> Ptr VkBufferMemoryRequirementsInfo2
-> Ptr VkMemoryRequirements2
-> IO ()
vkGetBufferMemoryRequirements2 = VkDevice
-> Ptr VkBufferMemoryRequirementsInfo2
-> Ptr VkMemoryRequirements2
-> IO ()
vkGetBufferMemoryRequirements2Safe

#endif
{-# INLINE vkGetBufferMemoryRequirements2 #-}

-- | > void vkGetBufferMemoryRequirements2
--   >     ( VkDevice device
--   >     , const VkBufferMemoryRequirementsInfo2* pInfo
--   >     , VkMemoryRequirements2* pMemoryRequirements
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 registry at www.khronos.org>
type HS_vkGetBufferMemoryRequirements2 =
     VkDevice -- ^ device
              ->
       Ptr VkBufferMemoryRequirementsInfo2 -- ^ pInfo
                                           ->
         Ptr VkMemoryRequirements2 -- ^ pMemoryRequirements
                                   -> IO ()

type PFN_vkGetBufferMemoryRequirements2 =
     FunPtr HS_vkGetBufferMemoryRequirements2

foreign import ccall unsafe "dynamic"
               unwrapVkGetBufferMemoryRequirements2Unsafe ::
               PFN_vkGetBufferMemoryRequirements2 ->
                 HS_vkGetBufferMemoryRequirements2

foreign import ccall safe "dynamic"
               unwrapVkGetBufferMemoryRequirements2Safe ::
               PFN_vkGetBufferMemoryRequirements2 ->
                 HS_vkGetBufferMemoryRequirements2

instance VulkanProc "vkGetBufferMemoryRequirements2" where
    type VkProcType "vkGetBufferMemoryRequirements2" =
         HS_vkGetBufferMemoryRequirements2
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkGetBufferMemoryRequirements2

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkGetBufferMemoryRequirements2)
-> VkProcType VkGetBufferMemoryRequirements2
unwrapVkProcPtrUnsafe = FunPtr (VkProcType VkGetBufferMemoryRequirements2)
-> VkProcType VkGetBufferMemoryRequirements2
PFN_vkGetBufferMemoryRequirements2
-> VkDevice
-> Ptr VkBufferMemoryRequirementsInfo2
-> Ptr VkMemoryRequirements2
-> IO ()
unwrapVkGetBufferMemoryRequirements2Unsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkGetBufferMemoryRequirements2)
-> VkProcType VkGetBufferMemoryRequirements2
unwrapVkProcPtrSafe = FunPtr (VkProcType VkGetBufferMemoryRequirements2)
-> VkProcType VkGetBufferMemoryRequirements2
PFN_vkGetBufferMemoryRequirements2
-> VkDevice
-> Ptr VkBufferMemoryRequirementsInfo2
-> Ptr VkMemoryRequirements2
-> IO ()
unwrapVkGetBufferMemoryRequirements2Safe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VkGetImageSparseMemoryRequirements2 :: CString

pattern $bVkGetImageSparseMemoryRequirements2 :: CString
$mVkGetImageSparseMemoryRequirements2 :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkGetImageSparseMemoryRequirements2 <-
        (is_VkGetImageSparseMemoryRequirements2 -> True)
  where
    VkGetImageSparseMemoryRequirements2
      = CString
_VkGetImageSparseMemoryRequirements2

{-# INLINE _VkGetImageSparseMemoryRequirements2 #-}

_VkGetImageSparseMemoryRequirements2 :: CString
_VkGetImageSparseMemoryRequirements2 :: CString
_VkGetImageSparseMemoryRequirements2
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkGetImageSparseMemoryRequirements2\NUL"#

{-# INLINE is_VkGetImageSparseMemoryRequirements2 #-}

is_VkGetImageSparseMemoryRequirements2 :: CString -> Bool
is_VkGetImageSparseMemoryRequirements2 :: CString -> Bool
is_VkGetImageSparseMemoryRequirements2
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkGetImageSparseMemoryRequirements2

type VkGetImageSparseMemoryRequirements2 =
     "vkGetImageSparseMemoryRequirements2"

-- |
-- > void vkGetImageSparseMemoryRequirements2
-- >     ( VkDevice device
-- >     , const VkImageSparseMemoryRequirementsInfo2* pInfo
-- >     , uint32_t* pSparseMemoryRequirementCount
-- >     , VkSparseImageMemoryRequirements2* pSparseMemoryRequirements
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetImageSparseMemoryRequirements2 <- vkGetDeviceProc @VkGetImageSparseMemoryRequirements2 vkDevice
--
-- or less efficient:
--
-- > myGetImageSparseMemoryRequirements2 <- vkGetProc @VkGetImageSparseMemoryRequirements2
--
-- __Note:__ @vkGetImageSparseMemoryRequirements2Unsafe@ and @vkGetImageSparseMemoryRequirements2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetImageSparseMemoryRequirements2@ is an alias
--           of @vkGetImageSparseMemoryRequirements2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetImageSparseMemoryRequirements2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkGetImageSparseMemoryRequirements2"
               vkGetImageSparseMemoryRequirements2Unsafe ::
               VkDevice -- ^ device
                        ->
                 Ptr VkImageSparseMemoryRequirementsInfo2 -- ^ pInfo
                                                          ->
                   Ptr Word32 -- ^ pSparseMemoryRequirementCount
                              -> Ptr VkSparseImageMemoryRequirements2 -- ^ pSparseMemoryRequirements
                                                                      -> IO ()

#else
vkGetImageSparseMemoryRequirements2Unsafe ::
                                          VkDevice -- ^ device
                                                   ->
                                            Ptr VkImageSparseMemoryRequirementsInfo2 -- ^ pInfo
                                                                                     ->
                                              Ptr Word32 -- ^ pSparseMemoryRequirementCount
                                                         ->
                                                Ptr VkSparseImageMemoryRequirements2 -- ^ pSparseMemoryRequirements
                                                                                     -> IO ()
vkGetImageSparseMemoryRequirements2Unsafe :: VkDevice
-> Ptr VkImageSparseMemoryRequirementsInfo2
-> Ptr Word32
-> Ptr VkSparseImageMemoryRequirements2
-> IO ()
vkGetImageSparseMemoryRequirements2Unsafe
  = IO
  (VkDevice
   -> Ptr VkImageSparseMemoryRequirementsInfo2
   -> Ptr Word32
   -> Ptr VkSparseImageMemoryRequirements2
   -> IO ())
-> VkDevice
-> Ptr VkImageSparseMemoryRequirementsInfo2
-> Ptr Word32
-> Ptr VkSparseImageMemoryRequirements2
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkGetImageSparseMemoryRequirements2)

{-# NOINLINE vkGetImageSparseMemoryRequirements2Unsafe #-}
#endif

-- |
-- > void vkGetImageSparseMemoryRequirements2
-- >     ( VkDevice device
-- >     , const VkImageSparseMemoryRequirementsInfo2* pInfo
-- >     , uint32_t* pSparseMemoryRequirementCount
-- >     , VkSparseImageMemoryRequirements2* pSparseMemoryRequirements
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetImageSparseMemoryRequirements2 <- vkGetDeviceProc @VkGetImageSparseMemoryRequirements2 vkDevice
--
-- or less efficient:
--
-- > myGetImageSparseMemoryRequirements2 <- vkGetProc @VkGetImageSparseMemoryRequirements2
--
-- __Note:__ @vkGetImageSparseMemoryRequirements2Unsafe@ and @vkGetImageSparseMemoryRequirements2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetImageSparseMemoryRequirements2@ is an alias
--           of @vkGetImageSparseMemoryRequirements2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetImageSparseMemoryRequirements2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkGetImageSparseMemoryRequirements2"
               vkGetImageSparseMemoryRequirements2Safe ::
               VkDevice -- ^ device
                        ->
                 Ptr VkImageSparseMemoryRequirementsInfo2 -- ^ pInfo
                                                          ->
                   Ptr Word32 -- ^ pSparseMemoryRequirementCount
                              -> Ptr VkSparseImageMemoryRequirements2 -- ^ pSparseMemoryRequirements
                                                                      -> IO ()

#else
vkGetImageSparseMemoryRequirements2Safe ::
                                        VkDevice -- ^ device
                                                 ->
                                          Ptr VkImageSparseMemoryRequirementsInfo2 -- ^ pInfo
                                                                                   ->
                                            Ptr Word32 -- ^ pSparseMemoryRequirementCount
                                                       ->
                                              Ptr VkSparseImageMemoryRequirements2 -- ^ pSparseMemoryRequirements
                                                                                   -> IO ()
vkGetImageSparseMemoryRequirements2Safe :: VkDevice
-> Ptr VkImageSparseMemoryRequirementsInfo2
-> Ptr Word32
-> Ptr VkSparseImageMemoryRequirements2
-> IO ()
vkGetImageSparseMemoryRequirements2Safe
  = IO
  (VkDevice
   -> Ptr VkImageSparseMemoryRequirementsInfo2
   -> Ptr Word32
   -> Ptr VkSparseImageMemoryRequirements2
   -> IO ())
-> VkDevice
-> Ptr VkImageSparseMemoryRequirementsInfo2
-> Ptr Word32
-> Ptr VkSparseImageMemoryRequirements2
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkGetImageSparseMemoryRequirements2)

{-# NOINLINE vkGetImageSparseMemoryRequirements2Safe #-}
#endif

-- |
-- > void vkGetImageSparseMemoryRequirements2
-- >     ( VkDevice device
-- >     , const VkImageSparseMemoryRequirementsInfo2* pInfo
-- >     , uint32_t* pSparseMemoryRequirementCount
-- >     , VkSparseImageMemoryRequirements2* pSparseMemoryRequirements
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetImageSparseMemoryRequirements2 <- vkGetDeviceProc @VkGetImageSparseMemoryRequirements2 vkDevice
--
-- or less efficient:
--
-- > myGetImageSparseMemoryRequirements2 <- vkGetProc @VkGetImageSparseMemoryRequirements2
--
-- __Note:__ @vkGetImageSparseMemoryRequirements2Unsafe@ and @vkGetImageSparseMemoryRequirements2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetImageSparseMemoryRequirements2@ is an alias
--           of @vkGetImageSparseMemoryRequirements2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetImageSparseMemoryRequirements2Safe@.
--
vkGetImageSparseMemoryRequirements2 ::
                                    VkDevice -- ^ device
                                             ->
                                      Ptr VkImageSparseMemoryRequirementsInfo2 -- ^ pInfo
                                                                               ->
                                        Ptr Word32 -- ^ pSparseMemoryRequirementCount
                                                   -> Ptr VkSparseImageMemoryRequirements2 -- ^ pSparseMemoryRequirements
                                                                                           -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkGetImageSparseMemoryRequirements2
  = vkGetImageSparseMemoryRequirements2Unsafe
#else
vkGetImageSparseMemoryRequirements2 :: VkDevice
-> Ptr VkImageSparseMemoryRequirementsInfo2
-> Ptr Word32
-> Ptr VkSparseImageMemoryRequirements2
-> IO ()
vkGetImageSparseMemoryRequirements2
  = VkDevice
-> Ptr VkImageSparseMemoryRequirementsInfo2
-> Ptr Word32
-> Ptr VkSparseImageMemoryRequirements2
-> IO ()
vkGetImageSparseMemoryRequirements2Safe

#endif
{-# INLINE vkGetImageSparseMemoryRequirements2 #-}

-- | > void vkGetImageSparseMemoryRequirements2
--   >     ( VkDevice device
--   >     , const VkImageSparseMemoryRequirementsInfo2* pInfo
--   >     , uint32_t* pSparseMemoryRequirementCount
--   >     , VkSparseImageMemoryRequirements2* pSparseMemoryRequirements
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 registry at www.khronos.org>
type HS_vkGetImageSparseMemoryRequirements2 =
     VkDevice -- ^ device
              ->
       Ptr VkImageSparseMemoryRequirementsInfo2 -- ^ pInfo
                                                ->
         Ptr Word32 -- ^ pSparseMemoryRequirementCount
                    -> Ptr VkSparseImageMemoryRequirements2 -- ^ pSparseMemoryRequirements
                                                            -> IO ()

type PFN_vkGetImageSparseMemoryRequirements2 =
     FunPtr HS_vkGetImageSparseMemoryRequirements2

foreign import ccall unsafe "dynamic"
               unwrapVkGetImageSparseMemoryRequirements2Unsafe ::
               PFN_vkGetImageSparseMemoryRequirements2 ->
                 HS_vkGetImageSparseMemoryRequirements2

foreign import ccall safe "dynamic"
               unwrapVkGetImageSparseMemoryRequirements2Safe ::
               PFN_vkGetImageSparseMemoryRequirements2 ->
                 HS_vkGetImageSparseMemoryRequirements2

instance VulkanProc "vkGetImageSparseMemoryRequirements2" where
    type VkProcType "vkGetImageSparseMemoryRequirements2" =
         HS_vkGetImageSparseMemoryRequirements2
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkGetImageSparseMemoryRequirements2

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkGetImageSparseMemoryRequirements2)
-> VkProcType VkGetImageSparseMemoryRequirements2
unwrapVkProcPtrUnsafe
      = FunPtr (VkProcType VkGetImageSparseMemoryRequirements2)
-> VkProcType VkGetImageSparseMemoryRequirements2
PFN_vkGetImageSparseMemoryRequirements2
-> VkDevice
-> Ptr VkImageSparseMemoryRequirementsInfo2
-> Ptr Word32
-> Ptr VkSparseImageMemoryRequirements2
-> IO ()
unwrapVkGetImageSparseMemoryRequirements2Unsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkGetImageSparseMemoryRequirements2)
-> VkProcType VkGetImageSparseMemoryRequirements2
unwrapVkProcPtrSafe = FunPtr (VkProcType VkGetImageSparseMemoryRequirements2)
-> VkProcType VkGetImageSparseMemoryRequirements2
PFN_vkGetImageSparseMemoryRequirements2
-> VkDevice
-> Ptr VkImageSparseMemoryRequirementsInfo2
-> Ptr Word32
-> Ptr VkSparseImageMemoryRequirements2
-> IO ()
unwrapVkGetImageSparseMemoryRequirements2Safe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 :: VkStructureType
$mVK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 =
        VkStructureType 1000146000

pattern VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 :: VkStructureType
$mVK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 =
        VkStructureType 1000146001

pattern VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2
        :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 :: VkStructureType
$mVK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 =
        VkStructureType 1000146002

pattern VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 :: VkStructureType
$mVK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 =
        VkStructureType 1000146003

pattern VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 :: VkStructureType
$mVK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 =
        VkStructureType 1000146004

pattern VkGetPhysicalDeviceFeatures2 :: CString

pattern $bVkGetPhysicalDeviceFeatures2 :: CString
$mVkGetPhysicalDeviceFeatures2 :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkGetPhysicalDeviceFeatures2 <-
        (is_VkGetPhysicalDeviceFeatures2 -> True)
  where
    VkGetPhysicalDeviceFeatures2 = CString
_VkGetPhysicalDeviceFeatures2

{-# INLINE _VkGetPhysicalDeviceFeatures2 #-}

_VkGetPhysicalDeviceFeatures2 :: CString
_VkGetPhysicalDeviceFeatures2 :: CString
_VkGetPhysicalDeviceFeatures2
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkGetPhysicalDeviceFeatures2\NUL"#

{-# INLINE is_VkGetPhysicalDeviceFeatures2 #-}

is_VkGetPhysicalDeviceFeatures2 :: CString -> Bool
is_VkGetPhysicalDeviceFeatures2 :: CString -> Bool
is_VkGetPhysicalDeviceFeatures2
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkGetPhysicalDeviceFeatures2

type VkGetPhysicalDeviceFeatures2 = "vkGetPhysicalDeviceFeatures2"

-- |
-- > void vkGetPhysicalDeviceFeatures2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , VkPhysicalDeviceFeatures2* pFeatures
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceFeatures2 <- vkGetInstanceProc @VkGetPhysicalDeviceFeatures2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceFeatures2 <- vkGetProc @VkGetPhysicalDeviceFeatures2
--
-- __Note:__ @vkGetPhysicalDeviceFeatures2Unsafe@ and @vkGetPhysicalDeviceFeatures2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceFeatures2@ is an alias
--           of @vkGetPhysicalDeviceFeatures2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceFeatures2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkGetPhysicalDeviceFeatures2"
               vkGetPhysicalDeviceFeatures2Unsafe ::
               VkPhysicalDevice -- ^ physicalDevice
                                -> Ptr VkPhysicalDeviceFeatures2 -- ^ pFeatures
                                                                 -> IO ()

#else
vkGetPhysicalDeviceFeatures2Unsafe ::
                                   VkPhysicalDevice -- ^ physicalDevice
                                                    -> Ptr VkPhysicalDeviceFeatures2 -- ^ pFeatures
                                                                                     -> IO ()
vkGetPhysicalDeviceFeatures2Unsafe :: VkPhysicalDevice -> Ptr VkPhysicalDeviceFeatures2 -> IO ()
vkGetPhysicalDeviceFeatures2Unsafe
  = IO (VkPhysicalDevice -> Ptr VkPhysicalDeviceFeatures2 -> IO ())
-> VkPhysicalDevice -> Ptr VkPhysicalDeviceFeatures2 -> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkGetPhysicalDeviceFeatures2)

{-# NOINLINE vkGetPhysicalDeviceFeatures2Unsafe #-}
#endif

-- |
-- > void vkGetPhysicalDeviceFeatures2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , VkPhysicalDeviceFeatures2* pFeatures
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceFeatures2 <- vkGetInstanceProc @VkGetPhysicalDeviceFeatures2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceFeatures2 <- vkGetProc @VkGetPhysicalDeviceFeatures2
--
-- __Note:__ @vkGetPhysicalDeviceFeatures2Unsafe@ and @vkGetPhysicalDeviceFeatures2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceFeatures2@ is an alias
--           of @vkGetPhysicalDeviceFeatures2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceFeatures2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkGetPhysicalDeviceFeatures2"
               vkGetPhysicalDeviceFeatures2Safe ::
               VkPhysicalDevice -- ^ physicalDevice
                                -> Ptr VkPhysicalDeviceFeatures2 -- ^ pFeatures
                                                                 -> IO ()

#else
vkGetPhysicalDeviceFeatures2Safe ::
                                 VkPhysicalDevice -- ^ physicalDevice
                                                  -> Ptr VkPhysicalDeviceFeatures2 -- ^ pFeatures
                                                                                   -> IO ()
vkGetPhysicalDeviceFeatures2Safe :: VkPhysicalDevice -> Ptr VkPhysicalDeviceFeatures2 -> IO ()
vkGetPhysicalDeviceFeatures2Safe
  = IO (VkPhysicalDevice -> Ptr VkPhysicalDeviceFeatures2 -> IO ())
-> VkPhysicalDevice -> Ptr VkPhysicalDeviceFeatures2 -> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkGetPhysicalDeviceFeatures2)

{-# NOINLINE vkGetPhysicalDeviceFeatures2Safe #-}
#endif

-- |
-- > void vkGetPhysicalDeviceFeatures2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , VkPhysicalDeviceFeatures2* pFeatures
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceFeatures2 <- vkGetInstanceProc @VkGetPhysicalDeviceFeatures2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceFeatures2 <- vkGetProc @VkGetPhysicalDeviceFeatures2
--
-- __Note:__ @vkGetPhysicalDeviceFeatures2Unsafe@ and @vkGetPhysicalDeviceFeatures2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceFeatures2@ is an alias
--           of @vkGetPhysicalDeviceFeatures2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceFeatures2Safe@.
--
vkGetPhysicalDeviceFeatures2 ::
                             VkPhysicalDevice -- ^ physicalDevice
                                              -> Ptr VkPhysicalDeviceFeatures2 -- ^ pFeatures
                                                                               -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkGetPhysicalDeviceFeatures2 = vkGetPhysicalDeviceFeatures2Unsafe
#else
vkGetPhysicalDeviceFeatures2 :: VkPhysicalDevice -> Ptr VkPhysicalDeviceFeatures2 -> IO ()
vkGetPhysicalDeviceFeatures2 = VkPhysicalDevice -> Ptr VkPhysicalDeviceFeatures2 -> IO ()
vkGetPhysicalDeviceFeatures2Safe

#endif
{-# INLINE vkGetPhysicalDeviceFeatures2 #-}

-- | > void vkGetPhysicalDeviceFeatures2
--   >     ( VkPhysicalDevice physicalDevice
--   >     , VkPhysicalDeviceFeatures2* pFeatures
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 registry at www.khronos.org>
type HS_vkGetPhysicalDeviceFeatures2 =
     VkPhysicalDevice -- ^ physicalDevice
                      -> Ptr VkPhysicalDeviceFeatures2 -- ^ pFeatures
                                                       -> IO ()

type PFN_vkGetPhysicalDeviceFeatures2 =
     FunPtr HS_vkGetPhysicalDeviceFeatures2

foreign import ccall unsafe "dynamic"
               unwrapVkGetPhysicalDeviceFeatures2Unsafe ::
               PFN_vkGetPhysicalDeviceFeatures2 -> HS_vkGetPhysicalDeviceFeatures2

foreign import ccall safe "dynamic"
               unwrapVkGetPhysicalDeviceFeatures2Safe ::
               PFN_vkGetPhysicalDeviceFeatures2 -> HS_vkGetPhysicalDeviceFeatures2

instance VulkanProc "vkGetPhysicalDeviceFeatures2" where
    type VkProcType "vkGetPhysicalDeviceFeatures2" =
         HS_vkGetPhysicalDeviceFeatures2
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkGetPhysicalDeviceFeatures2

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkGetPhysicalDeviceFeatures2)
-> VkProcType VkGetPhysicalDeviceFeatures2
unwrapVkProcPtrUnsafe = FunPtr (VkProcType VkGetPhysicalDeviceFeatures2)
-> VkProcType VkGetPhysicalDeviceFeatures2
PFN_vkGetPhysicalDeviceFeatures2
-> VkPhysicalDevice -> Ptr VkPhysicalDeviceFeatures2 -> IO ()
unwrapVkGetPhysicalDeviceFeatures2Unsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkGetPhysicalDeviceFeatures2)
-> VkProcType VkGetPhysicalDeviceFeatures2
unwrapVkProcPtrSafe = FunPtr (VkProcType VkGetPhysicalDeviceFeatures2)
-> VkProcType VkGetPhysicalDeviceFeatures2
PFN_vkGetPhysicalDeviceFeatures2
-> VkPhysicalDevice -> Ptr VkPhysicalDeviceFeatures2 -> IO ()
unwrapVkGetPhysicalDeviceFeatures2Safe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VkGetPhysicalDeviceProperties2 :: CString

pattern $bVkGetPhysicalDeviceProperties2 :: CString
$mVkGetPhysicalDeviceProperties2 :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkGetPhysicalDeviceProperties2 <-
        (is_VkGetPhysicalDeviceProperties2 -> True)
  where
    VkGetPhysicalDeviceProperties2 = CString
_VkGetPhysicalDeviceProperties2

{-# INLINE _VkGetPhysicalDeviceProperties2 #-}

_VkGetPhysicalDeviceProperties2 :: CString
_VkGetPhysicalDeviceProperties2 :: CString
_VkGetPhysicalDeviceProperties2
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkGetPhysicalDeviceProperties2\NUL"#

{-# INLINE is_VkGetPhysicalDeviceProperties2 #-}

is_VkGetPhysicalDeviceProperties2 :: CString -> Bool
is_VkGetPhysicalDeviceProperties2 :: CString -> Bool
is_VkGetPhysicalDeviceProperties2
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkGetPhysicalDeviceProperties2

type VkGetPhysicalDeviceProperties2 =
     "vkGetPhysicalDeviceProperties2"

-- |
-- > void vkGetPhysicalDeviceProperties2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , VkPhysicalDeviceProperties2* pProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceProperties2 <- vkGetInstanceProc @VkGetPhysicalDeviceProperties2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceProperties2 <- vkGetProc @VkGetPhysicalDeviceProperties2
--
-- __Note:__ @vkGetPhysicalDeviceProperties2Unsafe@ and @vkGetPhysicalDeviceProperties2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceProperties2@ is an alias
--           of @vkGetPhysicalDeviceProperties2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceProperties2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkGetPhysicalDeviceProperties2"
               vkGetPhysicalDeviceProperties2Unsafe ::
               VkPhysicalDevice -- ^ physicalDevice
                                -> Ptr VkPhysicalDeviceProperties2 -- ^ pProperties
                                                                   -> IO ()

#else
vkGetPhysicalDeviceProperties2Unsafe ::
                                     VkPhysicalDevice -- ^ physicalDevice
                                                      -> Ptr VkPhysicalDeviceProperties2 -- ^ pProperties
                                                                                         -> IO ()
vkGetPhysicalDeviceProperties2Unsafe :: VkPhysicalDevice -> Ptr VkPhysicalDeviceProperties2 -> IO ()
vkGetPhysicalDeviceProperties2Unsafe
  = IO (VkPhysicalDevice -> Ptr VkPhysicalDeviceProperties2 -> IO ())
-> VkPhysicalDevice -> Ptr VkPhysicalDeviceProperties2 -> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkGetPhysicalDeviceProperties2)

{-# NOINLINE vkGetPhysicalDeviceProperties2Unsafe #-}
#endif

-- |
-- > void vkGetPhysicalDeviceProperties2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , VkPhysicalDeviceProperties2* pProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceProperties2 <- vkGetInstanceProc @VkGetPhysicalDeviceProperties2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceProperties2 <- vkGetProc @VkGetPhysicalDeviceProperties2
--
-- __Note:__ @vkGetPhysicalDeviceProperties2Unsafe@ and @vkGetPhysicalDeviceProperties2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceProperties2@ is an alias
--           of @vkGetPhysicalDeviceProperties2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceProperties2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkGetPhysicalDeviceProperties2"
               vkGetPhysicalDeviceProperties2Safe ::
               VkPhysicalDevice -- ^ physicalDevice
                                -> Ptr VkPhysicalDeviceProperties2 -- ^ pProperties
                                                                   -> IO ()

#else
vkGetPhysicalDeviceProperties2Safe ::
                                   VkPhysicalDevice -- ^ physicalDevice
                                                    -> Ptr VkPhysicalDeviceProperties2 -- ^ pProperties
                                                                                       -> IO ()
vkGetPhysicalDeviceProperties2Safe :: VkPhysicalDevice -> Ptr VkPhysicalDeviceProperties2 -> IO ()
vkGetPhysicalDeviceProperties2Safe
  = IO (VkPhysicalDevice -> Ptr VkPhysicalDeviceProperties2 -> IO ())
-> VkPhysicalDevice -> Ptr VkPhysicalDeviceProperties2 -> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkGetPhysicalDeviceProperties2)

{-# NOINLINE vkGetPhysicalDeviceProperties2Safe #-}
#endif

-- |
-- > void vkGetPhysicalDeviceProperties2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , VkPhysicalDeviceProperties2* pProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceProperties2 <- vkGetInstanceProc @VkGetPhysicalDeviceProperties2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceProperties2 <- vkGetProc @VkGetPhysicalDeviceProperties2
--
-- __Note:__ @vkGetPhysicalDeviceProperties2Unsafe@ and @vkGetPhysicalDeviceProperties2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceProperties2@ is an alias
--           of @vkGetPhysicalDeviceProperties2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceProperties2Safe@.
--
vkGetPhysicalDeviceProperties2 ::
                               VkPhysicalDevice -- ^ physicalDevice
                                                -> Ptr VkPhysicalDeviceProperties2 -- ^ pProperties
                                                                                   -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkGetPhysicalDeviceProperties2
  = vkGetPhysicalDeviceProperties2Unsafe
#else
vkGetPhysicalDeviceProperties2 :: VkPhysicalDevice -> Ptr VkPhysicalDeviceProperties2 -> IO ()
vkGetPhysicalDeviceProperties2 = VkPhysicalDevice -> Ptr VkPhysicalDeviceProperties2 -> IO ()
vkGetPhysicalDeviceProperties2Safe

#endif
{-# INLINE vkGetPhysicalDeviceProperties2 #-}

-- | > void vkGetPhysicalDeviceProperties2
--   >     ( VkPhysicalDevice physicalDevice
--   >     , VkPhysicalDeviceProperties2* pProperties
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 registry at www.khronos.org>
type HS_vkGetPhysicalDeviceProperties2 =
     VkPhysicalDevice -- ^ physicalDevice
                      -> Ptr VkPhysicalDeviceProperties2 -- ^ pProperties
                                                         -> IO ()

type PFN_vkGetPhysicalDeviceProperties2 =
     FunPtr HS_vkGetPhysicalDeviceProperties2

foreign import ccall unsafe "dynamic"
               unwrapVkGetPhysicalDeviceProperties2Unsafe ::
               PFN_vkGetPhysicalDeviceProperties2 ->
                 HS_vkGetPhysicalDeviceProperties2

foreign import ccall safe "dynamic"
               unwrapVkGetPhysicalDeviceProperties2Safe ::
               PFN_vkGetPhysicalDeviceProperties2 ->
                 HS_vkGetPhysicalDeviceProperties2

instance VulkanProc "vkGetPhysicalDeviceProperties2" where
    type VkProcType "vkGetPhysicalDeviceProperties2" =
         HS_vkGetPhysicalDeviceProperties2
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkGetPhysicalDeviceProperties2

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkGetPhysicalDeviceProperties2)
-> VkProcType VkGetPhysicalDeviceProperties2
unwrapVkProcPtrUnsafe = FunPtr (VkProcType VkGetPhysicalDeviceProperties2)
-> VkProcType VkGetPhysicalDeviceProperties2
PFN_vkGetPhysicalDeviceProperties2
-> VkPhysicalDevice -> Ptr VkPhysicalDeviceProperties2 -> IO ()
unwrapVkGetPhysicalDeviceProperties2Unsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkGetPhysicalDeviceProperties2)
-> VkProcType VkGetPhysicalDeviceProperties2
unwrapVkProcPtrSafe = FunPtr (VkProcType VkGetPhysicalDeviceProperties2)
-> VkProcType VkGetPhysicalDeviceProperties2
PFN_vkGetPhysicalDeviceProperties2
-> VkPhysicalDevice -> Ptr VkPhysicalDeviceProperties2 -> IO ()
unwrapVkGetPhysicalDeviceProperties2Safe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VkGetPhysicalDeviceFormatProperties2 :: CString

pattern $bVkGetPhysicalDeviceFormatProperties2 :: CString
$mVkGetPhysicalDeviceFormatProperties2 :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkGetPhysicalDeviceFormatProperties2 <-
        (is_VkGetPhysicalDeviceFormatProperties2 -> True)
  where
    VkGetPhysicalDeviceFormatProperties2
      = CString
_VkGetPhysicalDeviceFormatProperties2

{-# INLINE _VkGetPhysicalDeviceFormatProperties2 #-}

_VkGetPhysicalDeviceFormatProperties2 :: CString
_VkGetPhysicalDeviceFormatProperties2 :: CString
_VkGetPhysicalDeviceFormatProperties2
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkGetPhysicalDeviceFormatProperties2\NUL"#

{-# INLINE is_VkGetPhysicalDeviceFormatProperties2 #-}

is_VkGetPhysicalDeviceFormatProperties2 :: CString -> Bool
is_VkGetPhysicalDeviceFormatProperties2 :: CString -> Bool
is_VkGetPhysicalDeviceFormatProperties2
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkGetPhysicalDeviceFormatProperties2

type VkGetPhysicalDeviceFormatProperties2 =
     "vkGetPhysicalDeviceFormatProperties2"

-- |
-- > void vkGetPhysicalDeviceFormatProperties2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , VkFormat format
-- >     , VkFormatProperties2* pFormatProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceFormatProperties2 <- vkGetInstanceProc @VkGetPhysicalDeviceFormatProperties2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceFormatProperties2 <- vkGetProc @VkGetPhysicalDeviceFormatProperties2
--
-- __Note:__ @vkGetPhysicalDeviceFormatProperties2Unsafe@ and @vkGetPhysicalDeviceFormatProperties2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceFormatProperties2@ is an alias
--           of @vkGetPhysicalDeviceFormatProperties2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceFormatProperties2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkGetPhysicalDeviceFormatProperties2"
               vkGetPhysicalDeviceFormatProperties2Unsafe ::
               VkPhysicalDevice -- ^ physicalDevice
                                -> VkFormat -- ^ format
                                            -> Ptr VkFormatProperties2 -- ^ pFormatProperties
                                                                       -> IO ()

#else
vkGetPhysicalDeviceFormatProperties2Unsafe ::
                                           VkPhysicalDevice -- ^ physicalDevice
                                                            ->
                                             VkFormat -- ^ format
                                                      -> Ptr VkFormatProperties2 -- ^ pFormatProperties
                                                                                 -> IO ()
vkGetPhysicalDeviceFormatProperties2Unsafe :: VkPhysicalDevice -> VkFormat -> Ptr VkFormatProperties2 -> IO ()
vkGetPhysicalDeviceFormatProperties2Unsafe
  = IO
  (VkPhysicalDevice -> VkFormat -> Ptr VkFormatProperties2 -> IO ())
-> VkPhysicalDevice -> VkFormat -> Ptr VkFormatProperties2 -> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkGetPhysicalDeviceFormatProperties2)

{-# NOINLINE vkGetPhysicalDeviceFormatProperties2Unsafe #-}
#endif

-- |
-- > void vkGetPhysicalDeviceFormatProperties2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , VkFormat format
-- >     , VkFormatProperties2* pFormatProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceFormatProperties2 <- vkGetInstanceProc @VkGetPhysicalDeviceFormatProperties2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceFormatProperties2 <- vkGetProc @VkGetPhysicalDeviceFormatProperties2
--
-- __Note:__ @vkGetPhysicalDeviceFormatProperties2Unsafe@ and @vkGetPhysicalDeviceFormatProperties2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceFormatProperties2@ is an alias
--           of @vkGetPhysicalDeviceFormatProperties2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceFormatProperties2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkGetPhysicalDeviceFormatProperties2"
               vkGetPhysicalDeviceFormatProperties2Safe ::
               VkPhysicalDevice -- ^ physicalDevice
                                -> VkFormat -- ^ format
                                            -> Ptr VkFormatProperties2 -- ^ pFormatProperties
                                                                       -> IO ()

#else
vkGetPhysicalDeviceFormatProperties2Safe ::
                                         VkPhysicalDevice -- ^ physicalDevice
                                                          ->
                                           VkFormat -- ^ format
                                                    -> Ptr VkFormatProperties2 -- ^ pFormatProperties
                                                                               -> IO ()
vkGetPhysicalDeviceFormatProperties2Safe :: VkPhysicalDevice -> VkFormat -> Ptr VkFormatProperties2 -> IO ()
vkGetPhysicalDeviceFormatProperties2Safe
  = IO
  (VkPhysicalDevice -> VkFormat -> Ptr VkFormatProperties2 -> IO ())
-> VkPhysicalDevice -> VkFormat -> Ptr VkFormatProperties2 -> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkGetPhysicalDeviceFormatProperties2)

{-# NOINLINE vkGetPhysicalDeviceFormatProperties2Safe #-}
#endif

-- |
-- > void vkGetPhysicalDeviceFormatProperties2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , VkFormat format
-- >     , VkFormatProperties2* pFormatProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceFormatProperties2 <- vkGetInstanceProc @VkGetPhysicalDeviceFormatProperties2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceFormatProperties2 <- vkGetProc @VkGetPhysicalDeviceFormatProperties2
--
-- __Note:__ @vkGetPhysicalDeviceFormatProperties2Unsafe@ and @vkGetPhysicalDeviceFormatProperties2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceFormatProperties2@ is an alias
--           of @vkGetPhysicalDeviceFormatProperties2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceFormatProperties2Safe@.
--
vkGetPhysicalDeviceFormatProperties2 ::
                                     VkPhysicalDevice -- ^ physicalDevice
                                                      ->
                                       VkFormat -- ^ format
                                                -> Ptr VkFormatProperties2 -- ^ pFormatProperties
                                                                           -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkGetPhysicalDeviceFormatProperties2
  = vkGetPhysicalDeviceFormatProperties2Unsafe
#else
vkGetPhysicalDeviceFormatProperties2 :: VkPhysicalDevice -> VkFormat -> Ptr VkFormatProperties2 -> IO ()
vkGetPhysicalDeviceFormatProperties2
  = VkPhysicalDevice -> VkFormat -> Ptr VkFormatProperties2 -> IO ()
vkGetPhysicalDeviceFormatProperties2Safe

#endif
{-# INLINE vkGetPhysicalDeviceFormatProperties2 #-}

-- | > void vkGetPhysicalDeviceFormatProperties2
--   >     ( VkPhysicalDevice physicalDevice
--   >     , VkFormat format
--   >     , VkFormatProperties2* pFormatProperties
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 registry at www.khronos.org>
type HS_vkGetPhysicalDeviceFormatProperties2 =
     VkPhysicalDevice -- ^ physicalDevice
                      -> VkFormat -- ^ format
                                  -> Ptr VkFormatProperties2 -- ^ pFormatProperties
                                                             -> IO ()

type PFN_vkGetPhysicalDeviceFormatProperties2 =
     FunPtr HS_vkGetPhysicalDeviceFormatProperties2

foreign import ccall unsafe "dynamic"
               unwrapVkGetPhysicalDeviceFormatProperties2Unsafe ::
               PFN_vkGetPhysicalDeviceFormatProperties2 ->
                 HS_vkGetPhysicalDeviceFormatProperties2

foreign import ccall safe "dynamic"
               unwrapVkGetPhysicalDeviceFormatProperties2Safe ::
               PFN_vkGetPhysicalDeviceFormatProperties2 ->
                 HS_vkGetPhysicalDeviceFormatProperties2

instance VulkanProc "vkGetPhysicalDeviceFormatProperties2" where
    type VkProcType "vkGetPhysicalDeviceFormatProperties2" =
         HS_vkGetPhysicalDeviceFormatProperties2
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkGetPhysicalDeviceFormatProperties2

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkGetPhysicalDeviceFormatProperties2)
-> VkProcType VkGetPhysicalDeviceFormatProperties2
unwrapVkProcPtrUnsafe
      = FunPtr (VkProcType VkGetPhysicalDeviceFormatProperties2)
-> VkProcType VkGetPhysicalDeviceFormatProperties2
PFN_vkGetPhysicalDeviceFormatProperties2
-> VkPhysicalDevice -> VkFormat -> Ptr VkFormatProperties2 -> IO ()
unwrapVkGetPhysicalDeviceFormatProperties2Unsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkGetPhysicalDeviceFormatProperties2)
-> VkProcType VkGetPhysicalDeviceFormatProperties2
unwrapVkProcPtrSafe
      = FunPtr (VkProcType VkGetPhysicalDeviceFormatProperties2)
-> VkProcType VkGetPhysicalDeviceFormatProperties2
PFN_vkGetPhysicalDeviceFormatProperties2
-> VkPhysicalDevice -> VkFormat -> Ptr VkFormatProperties2 -> IO ()
unwrapVkGetPhysicalDeviceFormatProperties2Safe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VkGetPhysicalDeviceImageFormatProperties2 :: CString

pattern $bVkGetPhysicalDeviceImageFormatProperties2 :: CString
$mVkGetPhysicalDeviceImageFormatProperties2 :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkGetPhysicalDeviceImageFormatProperties2 <-
        (is_VkGetPhysicalDeviceImageFormatProperties2 -> True)
  where
    VkGetPhysicalDeviceImageFormatProperties2
      = CString
_VkGetPhysicalDeviceImageFormatProperties2

{-# INLINE _VkGetPhysicalDeviceImageFormatProperties2 #-}

_VkGetPhysicalDeviceImageFormatProperties2 :: CString
_VkGetPhysicalDeviceImageFormatProperties2 :: CString
_VkGetPhysicalDeviceImageFormatProperties2
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkGetPhysicalDeviceImageFormatProperties2\NUL"#

{-# INLINE is_VkGetPhysicalDeviceImageFormatProperties2 #-}

is_VkGetPhysicalDeviceImageFormatProperties2 :: CString -> Bool
is_VkGetPhysicalDeviceImageFormatProperties2 :: CString -> Bool
is_VkGetPhysicalDeviceImageFormatProperties2
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkGetPhysicalDeviceImageFormatProperties2

type VkGetPhysicalDeviceImageFormatProperties2 =
     "vkGetPhysicalDeviceImageFormatProperties2"

-- |
-- Success codes: 'VK_SUCCESS'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_FORMAT_NOT_SUPPORTED'.
--
-- > VkResult vkGetPhysicalDeviceImageFormatProperties2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo
-- >     , VkImageFormatProperties2* pImageFormatProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceImageFormatProperties2 <- vkGetInstanceProc @VkGetPhysicalDeviceImageFormatProperties2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceImageFormatProperties2 <- vkGetProc @VkGetPhysicalDeviceImageFormatProperties2
--
-- __Note:__ @vkGetPhysicalDeviceImageFormatProperties2Unsafe@ and @vkGetPhysicalDeviceImageFormatProperties2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceImageFormatProperties2@ is an alias
--           of @vkGetPhysicalDeviceImageFormatProperties2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceImageFormatProperties2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe
               "vkGetPhysicalDeviceImageFormatProperties2"
               vkGetPhysicalDeviceImageFormatProperties2Unsafe ::
               VkPhysicalDevice -- ^ physicalDevice
                                ->
                 Ptr VkPhysicalDeviceImageFormatInfo2 -- ^ pImageFormatInfo
                                                      ->
                   Ptr VkImageFormatProperties2 -- ^ pImageFormatProperties
                                                -> IO VkResult

#else
vkGetPhysicalDeviceImageFormatProperties2Unsafe ::
                                                VkPhysicalDevice -- ^ physicalDevice
                                                                 ->
                                                  Ptr VkPhysicalDeviceImageFormatInfo2 -- ^ pImageFormatInfo
                                                                                       ->
                                                    Ptr VkImageFormatProperties2 -- ^ pImageFormatProperties
                                                                                 -> IO VkResult
vkGetPhysicalDeviceImageFormatProperties2Unsafe :: VkPhysicalDevice
-> Ptr VkPhysicalDeviceImageFormatInfo2
-> Ptr VkImageFormatProperties2
-> IO VkResult
vkGetPhysicalDeviceImageFormatProperties2Unsafe
  = IO
  (VkPhysicalDevice
   -> Ptr VkPhysicalDeviceImageFormatInfo2
   -> Ptr VkImageFormatProperties2
   -> IO VkResult)
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceImageFormatInfo2
-> Ptr VkImageFormatProperties2
-> IO VkResult
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkGetPhysicalDeviceImageFormatProperties2)

{-# NOINLINE vkGetPhysicalDeviceImageFormatProperties2Unsafe #-}
#endif

-- |
-- Success codes: 'VK_SUCCESS'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_FORMAT_NOT_SUPPORTED'.
--
-- > VkResult vkGetPhysicalDeviceImageFormatProperties2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo
-- >     , VkImageFormatProperties2* pImageFormatProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceImageFormatProperties2 <- vkGetInstanceProc @VkGetPhysicalDeviceImageFormatProperties2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceImageFormatProperties2 <- vkGetProc @VkGetPhysicalDeviceImageFormatProperties2
--
-- __Note:__ @vkGetPhysicalDeviceImageFormatProperties2Unsafe@ and @vkGetPhysicalDeviceImageFormatProperties2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceImageFormatProperties2@ is an alias
--           of @vkGetPhysicalDeviceImageFormatProperties2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceImageFormatProperties2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe
               "vkGetPhysicalDeviceImageFormatProperties2"
               vkGetPhysicalDeviceImageFormatProperties2Safe ::
               VkPhysicalDevice -- ^ physicalDevice
                                ->
                 Ptr VkPhysicalDeviceImageFormatInfo2 -- ^ pImageFormatInfo
                                                      ->
                   Ptr VkImageFormatProperties2 -- ^ pImageFormatProperties
                                                -> IO VkResult

#else
vkGetPhysicalDeviceImageFormatProperties2Safe ::
                                              VkPhysicalDevice -- ^ physicalDevice
                                                               ->
                                                Ptr VkPhysicalDeviceImageFormatInfo2 -- ^ pImageFormatInfo
                                                                                     ->
                                                  Ptr VkImageFormatProperties2 -- ^ pImageFormatProperties
                                                                               -> IO VkResult
vkGetPhysicalDeviceImageFormatProperties2Safe :: VkPhysicalDevice
-> Ptr VkPhysicalDeviceImageFormatInfo2
-> Ptr VkImageFormatProperties2
-> IO VkResult
vkGetPhysicalDeviceImageFormatProperties2Safe
  = IO
  (VkPhysicalDevice
   -> Ptr VkPhysicalDeviceImageFormatInfo2
   -> Ptr VkImageFormatProperties2
   -> IO VkResult)
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceImageFormatInfo2
-> Ptr VkImageFormatProperties2
-> IO VkResult
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkGetPhysicalDeviceImageFormatProperties2)

{-# NOINLINE vkGetPhysicalDeviceImageFormatProperties2Safe #-}
#endif

-- |
-- Success codes: 'VK_SUCCESS'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_FORMAT_NOT_SUPPORTED'.
--
-- > VkResult vkGetPhysicalDeviceImageFormatProperties2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo
-- >     , VkImageFormatProperties2* pImageFormatProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceImageFormatProperties2 <- vkGetInstanceProc @VkGetPhysicalDeviceImageFormatProperties2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceImageFormatProperties2 <- vkGetProc @VkGetPhysicalDeviceImageFormatProperties2
--
-- __Note:__ @vkGetPhysicalDeviceImageFormatProperties2Unsafe@ and @vkGetPhysicalDeviceImageFormatProperties2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceImageFormatProperties2@ is an alias
--           of @vkGetPhysicalDeviceImageFormatProperties2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceImageFormatProperties2Safe@.
--
vkGetPhysicalDeviceImageFormatProperties2 ::
                                          VkPhysicalDevice -- ^ physicalDevice
                                                           ->
                                            Ptr VkPhysicalDeviceImageFormatInfo2 -- ^ pImageFormatInfo
                                                                                 ->
                                              Ptr VkImageFormatProperties2 -- ^ pImageFormatProperties
                                                                           -> IO VkResult
#ifdef UNSAFE_FFI_DEFAULT
vkGetPhysicalDeviceImageFormatProperties2
  = vkGetPhysicalDeviceImageFormatProperties2Unsafe
#else
vkGetPhysicalDeviceImageFormatProperties2 :: VkPhysicalDevice
-> Ptr VkPhysicalDeviceImageFormatInfo2
-> Ptr VkImageFormatProperties2
-> IO VkResult
vkGetPhysicalDeviceImageFormatProperties2
  = VkPhysicalDevice
-> Ptr VkPhysicalDeviceImageFormatInfo2
-> Ptr VkImageFormatProperties2
-> IO VkResult
vkGetPhysicalDeviceImageFormatProperties2Safe

#endif
{-# INLINE vkGetPhysicalDeviceImageFormatProperties2 #-}

-- | Success codes: 'VK_SUCCESS'.
--
--   Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_FORMAT_NOT_SUPPORTED'.
--
--   > VkResult vkGetPhysicalDeviceImageFormatProperties2
--   >     ( VkPhysicalDevice physicalDevice
--   >     , const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo
--   >     , VkImageFormatProperties2* pImageFormatProperties
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 registry at www.khronos.org>
type HS_vkGetPhysicalDeviceImageFormatProperties2 =
     VkPhysicalDevice -- ^ physicalDevice
                      ->
       Ptr VkPhysicalDeviceImageFormatInfo2 -- ^ pImageFormatInfo
                                            ->
         Ptr VkImageFormatProperties2 -- ^ pImageFormatProperties
                                      -> IO VkResult

type PFN_vkGetPhysicalDeviceImageFormatProperties2 =
     FunPtr HS_vkGetPhysicalDeviceImageFormatProperties2

foreign import ccall unsafe "dynamic"
               unwrapVkGetPhysicalDeviceImageFormatProperties2Unsafe ::
               PFN_vkGetPhysicalDeviceImageFormatProperties2 ->
                 HS_vkGetPhysicalDeviceImageFormatProperties2

foreign import ccall safe "dynamic"
               unwrapVkGetPhysicalDeviceImageFormatProperties2Safe ::
               PFN_vkGetPhysicalDeviceImageFormatProperties2 ->
                 HS_vkGetPhysicalDeviceImageFormatProperties2

instance VulkanProc "vkGetPhysicalDeviceImageFormatProperties2"
         where
    type VkProcType "vkGetPhysicalDeviceImageFormatProperties2" =
         HS_vkGetPhysicalDeviceImageFormatProperties2
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkGetPhysicalDeviceImageFormatProperties2

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkGetPhysicalDeviceImageFormatProperties2)
-> VkProcType VkGetPhysicalDeviceImageFormatProperties2
unwrapVkProcPtrUnsafe
      = FunPtr (VkProcType VkGetPhysicalDeviceImageFormatProperties2)
-> VkProcType VkGetPhysicalDeviceImageFormatProperties2
PFN_vkGetPhysicalDeviceImageFormatProperties2
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceImageFormatInfo2
-> Ptr VkImageFormatProperties2
-> IO VkResult
unwrapVkGetPhysicalDeviceImageFormatProperties2Unsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkGetPhysicalDeviceImageFormatProperties2)
-> VkProcType VkGetPhysicalDeviceImageFormatProperties2
unwrapVkProcPtrSafe
      = FunPtr (VkProcType VkGetPhysicalDeviceImageFormatProperties2)
-> VkProcType VkGetPhysicalDeviceImageFormatProperties2
PFN_vkGetPhysicalDeviceImageFormatProperties2
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceImageFormatInfo2
-> Ptr VkImageFormatProperties2
-> IO VkResult
unwrapVkGetPhysicalDeviceImageFormatProperties2Safe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VkGetPhysicalDeviceQueueFamilyProperties2 :: CString

pattern $bVkGetPhysicalDeviceQueueFamilyProperties2 :: CString
$mVkGetPhysicalDeviceQueueFamilyProperties2 :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkGetPhysicalDeviceQueueFamilyProperties2 <-
        (is_VkGetPhysicalDeviceQueueFamilyProperties2 -> True)
  where
    VkGetPhysicalDeviceQueueFamilyProperties2
      = CString
_VkGetPhysicalDeviceQueueFamilyProperties2

{-# INLINE _VkGetPhysicalDeviceQueueFamilyProperties2 #-}

_VkGetPhysicalDeviceQueueFamilyProperties2 :: CString
_VkGetPhysicalDeviceQueueFamilyProperties2 :: CString
_VkGetPhysicalDeviceQueueFamilyProperties2
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkGetPhysicalDeviceQueueFamilyProperties2\NUL"#

{-# INLINE is_VkGetPhysicalDeviceQueueFamilyProperties2 #-}

is_VkGetPhysicalDeviceQueueFamilyProperties2 :: CString -> Bool
is_VkGetPhysicalDeviceQueueFamilyProperties2 :: CString -> Bool
is_VkGetPhysicalDeviceQueueFamilyProperties2
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkGetPhysicalDeviceQueueFamilyProperties2

type VkGetPhysicalDeviceQueueFamilyProperties2 =
     "vkGetPhysicalDeviceQueueFamilyProperties2"

-- |
-- > void vkGetPhysicalDeviceQueueFamilyProperties2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , uint32_t* pQueueFamilyPropertyCount
-- >     , VkQueueFamilyProperties2* pQueueFamilyProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceQueueFamilyProperties2 <- vkGetInstanceProc @VkGetPhysicalDeviceQueueFamilyProperties2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceQueueFamilyProperties2 <- vkGetProc @VkGetPhysicalDeviceQueueFamilyProperties2
--
-- __Note:__ @vkGetPhysicalDeviceQueueFamilyProperties2Unsafe@ and @vkGetPhysicalDeviceQueueFamilyProperties2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceQueueFamilyProperties2@ is an alias
--           of @vkGetPhysicalDeviceQueueFamilyProperties2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceQueueFamilyProperties2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe
               "vkGetPhysicalDeviceQueueFamilyProperties2"
               vkGetPhysicalDeviceQueueFamilyProperties2Unsafe ::
               VkPhysicalDevice -- ^ physicalDevice
                                ->
                 Ptr Word32 -- ^ pQueueFamilyPropertyCount
                            -> Ptr VkQueueFamilyProperties2 -- ^ pQueueFamilyProperties
                                                            -> IO ()

#else
vkGetPhysicalDeviceQueueFamilyProperties2Unsafe ::
                                                VkPhysicalDevice -- ^ physicalDevice
                                                                 ->
                                                  Ptr Word32 -- ^ pQueueFamilyPropertyCount
                                                             ->
                                                    Ptr VkQueueFamilyProperties2 -- ^ pQueueFamilyProperties
                                                                                 -> IO ()
vkGetPhysicalDeviceQueueFamilyProperties2Unsafe :: VkPhysicalDevice
-> Ptr Word32 -> Ptr VkQueueFamilyProperties2 -> IO ()
vkGetPhysicalDeviceQueueFamilyProperties2Unsafe
  = IO
  (VkPhysicalDevice
   -> Ptr Word32 -> Ptr VkQueueFamilyProperties2 -> IO ())
-> VkPhysicalDevice
-> Ptr Word32
-> Ptr VkQueueFamilyProperties2
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkGetPhysicalDeviceQueueFamilyProperties2)

{-# NOINLINE vkGetPhysicalDeviceQueueFamilyProperties2Unsafe #-}
#endif

-- |
-- > void vkGetPhysicalDeviceQueueFamilyProperties2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , uint32_t* pQueueFamilyPropertyCount
-- >     , VkQueueFamilyProperties2* pQueueFamilyProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceQueueFamilyProperties2 <- vkGetInstanceProc @VkGetPhysicalDeviceQueueFamilyProperties2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceQueueFamilyProperties2 <- vkGetProc @VkGetPhysicalDeviceQueueFamilyProperties2
--
-- __Note:__ @vkGetPhysicalDeviceQueueFamilyProperties2Unsafe@ and @vkGetPhysicalDeviceQueueFamilyProperties2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceQueueFamilyProperties2@ is an alias
--           of @vkGetPhysicalDeviceQueueFamilyProperties2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceQueueFamilyProperties2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe
               "vkGetPhysicalDeviceQueueFamilyProperties2"
               vkGetPhysicalDeviceQueueFamilyProperties2Safe ::
               VkPhysicalDevice -- ^ physicalDevice
                                ->
                 Ptr Word32 -- ^ pQueueFamilyPropertyCount
                            -> Ptr VkQueueFamilyProperties2 -- ^ pQueueFamilyProperties
                                                            -> IO ()

#else
vkGetPhysicalDeviceQueueFamilyProperties2Safe ::
                                              VkPhysicalDevice -- ^ physicalDevice
                                                               ->
                                                Ptr Word32 -- ^ pQueueFamilyPropertyCount
                                                           -> Ptr VkQueueFamilyProperties2 -- ^ pQueueFamilyProperties
                                                                                           -> IO ()
vkGetPhysicalDeviceQueueFamilyProperties2Safe :: VkPhysicalDevice
-> Ptr Word32 -> Ptr VkQueueFamilyProperties2 -> IO ()
vkGetPhysicalDeviceQueueFamilyProperties2Safe
  = IO
  (VkPhysicalDevice
   -> Ptr Word32 -> Ptr VkQueueFamilyProperties2 -> IO ())
-> VkPhysicalDevice
-> Ptr Word32
-> Ptr VkQueueFamilyProperties2
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkGetPhysicalDeviceQueueFamilyProperties2)

{-# NOINLINE vkGetPhysicalDeviceQueueFamilyProperties2Safe #-}
#endif

-- |
-- > void vkGetPhysicalDeviceQueueFamilyProperties2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , uint32_t* pQueueFamilyPropertyCount
-- >     , VkQueueFamilyProperties2* pQueueFamilyProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceQueueFamilyProperties2 <- vkGetInstanceProc @VkGetPhysicalDeviceQueueFamilyProperties2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceQueueFamilyProperties2 <- vkGetProc @VkGetPhysicalDeviceQueueFamilyProperties2
--
-- __Note:__ @vkGetPhysicalDeviceQueueFamilyProperties2Unsafe@ and @vkGetPhysicalDeviceQueueFamilyProperties2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceQueueFamilyProperties2@ is an alias
--           of @vkGetPhysicalDeviceQueueFamilyProperties2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceQueueFamilyProperties2Safe@.
--
vkGetPhysicalDeviceQueueFamilyProperties2 ::
                                          VkPhysicalDevice -- ^ physicalDevice
                                                           ->
                                            Ptr Word32 -- ^ pQueueFamilyPropertyCount
                                                       -> Ptr VkQueueFamilyProperties2 -- ^ pQueueFamilyProperties
                                                                                       -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkGetPhysicalDeviceQueueFamilyProperties2
  = vkGetPhysicalDeviceQueueFamilyProperties2Unsafe
#else
vkGetPhysicalDeviceQueueFamilyProperties2 :: VkPhysicalDevice
-> Ptr Word32 -> Ptr VkQueueFamilyProperties2 -> IO ()
vkGetPhysicalDeviceQueueFamilyProperties2
  = VkPhysicalDevice
-> Ptr Word32 -> Ptr VkQueueFamilyProperties2 -> IO ()
vkGetPhysicalDeviceQueueFamilyProperties2Safe

#endif
{-# INLINE vkGetPhysicalDeviceQueueFamilyProperties2 #-}

-- | > void vkGetPhysicalDeviceQueueFamilyProperties2
--   >     ( VkPhysicalDevice physicalDevice
--   >     , uint32_t* pQueueFamilyPropertyCount
--   >     , VkQueueFamilyProperties2* pQueueFamilyProperties
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 registry at www.khronos.org>
type HS_vkGetPhysicalDeviceQueueFamilyProperties2 =
     VkPhysicalDevice -- ^ physicalDevice
                      ->
       Ptr Word32 -- ^ pQueueFamilyPropertyCount
                  -> Ptr VkQueueFamilyProperties2 -- ^ pQueueFamilyProperties
                                                  -> IO ()

type PFN_vkGetPhysicalDeviceQueueFamilyProperties2 =
     FunPtr HS_vkGetPhysicalDeviceQueueFamilyProperties2

foreign import ccall unsafe "dynamic"
               unwrapVkGetPhysicalDeviceQueueFamilyProperties2Unsafe ::
               PFN_vkGetPhysicalDeviceQueueFamilyProperties2 ->
                 HS_vkGetPhysicalDeviceQueueFamilyProperties2

foreign import ccall safe "dynamic"
               unwrapVkGetPhysicalDeviceQueueFamilyProperties2Safe ::
               PFN_vkGetPhysicalDeviceQueueFamilyProperties2 ->
                 HS_vkGetPhysicalDeviceQueueFamilyProperties2

instance VulkanProc "vkGetPhysicalDeviceQueueFamilyProperties2"
         where
    type VkProcType "vkGetPhysicalDeviceQueueFamilyProperties2" =
         HS_vkGetPhysicalDeviceQueueFamilyProperties2
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkGetPhysicalDeviceQueueFamilyProperties2

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkGetPhysicalDeviceQueueFamilyProperties2)
-> VkProcType VkGetPhysicalDeviceQueueFamilyProperties2
unwrapVkProcPtrUnsafe
      = FunPtr (VkProcType VkGetPhysicalDeviceQueueFamilyProperties2)
-> VkProcType VkGetPhysicalDeviceQueueFamilyProperties2
PFN_vkGetPhysicalDeviceQueueFamilyProperties2
-> VkPhysicalDevice
-> Ptr Word32
-> Ptr VkQueueFamilyProperties2
-> IO ()
unwrapVkGetPhysicalDeviceQueueFamilyProperties2Unsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkGetPhysicalDeviceQueueFamilyProperties2)
-> VkProcType VkGetPhysicalDeviceQueueFamilyProperties2
unwrapVkProcPtrSafe
      = FunPtr (VkProcType VkGetPhysicalDeviceQueueFamilyProperties2)
-> VkProcType VkGetPhysicalDeviceQueueFamilyProperties2
PFN_vkGetPhysicalDeviceQueueFamilyProperties2
-> VkPhysicalDevice
-> Ptr Word32
-> Ptr VkQueueFamilyProperties2
-> IO ()
unwrapVkGetPhysicalDeviceQueueFamilyProperties2Safe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VkGetPhysicalDeviceMemoryProperties2 :: CString

pattern $bVkGetPhysicalDeviceMemoryProperties2 :: CString
$mVkGetPhysicalDeviceMemoryProperties2 :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkGetPhysicalDeviceMemoryProperties2 <-
        (is_VkGetPhysicalDeviceMemoryProperties2 -> True)
  where
    VkGetPhysicalDeviceMemoryProperties2
      = CString
_VkGetPhysicalDeviceMemoryProperties2

{-# INLINE _VkGetPhysicalDeviceMemoryProperties2 #-}

_VkGetPhysicalDeviceMemoryProperties2 :: CString
_VkGetPhysicalDeviceMemoryProperties2 :: CString
_VkGetPhysicalDeviceMemoryProperties2
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkGetPhysicalDeviceMemoryProperties2\NUL"#

{-# INLINE is_VkGetPhysicalDeviceMemoryProperties2 #-}

is_VkGetPhysicalDeviceMemoryProperties2 :: CString -> Bool
is_VkGetPhysicalDeviceMemoryProperties2 :: CString -> Bool
is_VkGetPhysicalDeviceMemoryProperties2
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkGetPhysicalDeviceMemoryProperties2

type VkGetPhysicalDeviceMemoryProperties2 =
     "vkGetPhysicalDeviceMemoryProperties2"

-- |
-- > void vkGetPhysicalDeviceMemoryProperties2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , VkPhysicalDeviceMemoryProperties2* pMemoryProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceMemoryProperties2 <- vkGetInstanceProc @VkGetPhysicalDeviceMemoryProperties2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceMemoryProperties2 <- vkGetProc @VkGetPhysicalDeviceMemoryProperties2
--
-- __Note:__ @vkGetPhysicalDeviceMemoryProperties2Unsafe@ and @vkGetPhysicalDeviceMemoryProperties2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceMemoryProperties2@ is an alias
--           of @vkGetPhysicalDeviceMemoryProperties2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceMemoryProperties2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkGetPhysicalDeviceMemoryProperties2"
               vkGetPhysicalDeviceMemoryProperties2Unsafe ::
               VkPhysicalDevice -- ^ physicalDevice
                                -> Ptr VkPhysicalDeviceMemoryProperties2 -- ^ pMemoryProperties
                                                                         -> IO ()

#else
vkGetPhysicalDeviceMemoryProperties2Unsafe ::
                                           VkPhysicalDevice -- ^ physicalDevice
                                                            ->
                                             Ptr VkPhysicalDeviceMemoryProperties2 -- ^ pMemoryProperties
                                                                                   -> IO ()
vkGetPhysicalDeviceMemoryProperties2Unsafe :: VkPhysicalDevice -> Ptr VkPhysicalDeviceMemoryProperties2 -> IO ()
vkGetPhysicalDeviceMemoryProperties2Unsafe
  = IO
  (VkPhysicalDevice
   -> Ptr VkPhysicalDeviceMemoryProperties2 -> IO ())
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceMemoryProperties2
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkGetPhysicalDeviceMemoryProperties2)

{-# NOINLINE vkGetPhysicalDeviceMemoryProperties2Unsafe #-}
#endif

-- |
-- > void vkGetPhysicalDeviceMemoryProperties2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , VkPhysicalDeviceMemoryProperties2* pMemoryProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceMemoryProperties2 <- vkGetInstanceProc @VkGetPhysicalDeviceMemoryProperties2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceMemoryProperties2 <- vkGetProc @VkGetPhysicalDeviceMemoryProperties2
--
-- __Note:__ @vkGetPhysicalDeviceMemoryProperties2Unsafe@ and @vkGetPhysicalDeviceMemoryProperties2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceMemoryProperties2@ is an alias
--           of @vkGetPhysicalDeviceMemoryProperties2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceMemoryProperties2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkGetPhysicalDeviceMemoryProperties2"
               vkGetPhysicalDeviceMemoryProperties2Safe ::
               VkPhysicalDevice -- ^ physicalDevice
                                -> Ptr VkPhysicalDeviceMemoryProperties2 -- ^ pMemoryProperties
                                                                         -> IO ()

#else
vkGetPhysicalDeviceMemoryProperties2Safe ::
                                         VkPhysicalDevice -- ^ physicalDevice
                                                          ->
                                           Ptr VkPhysicalDeviceMemoryProperties2 -- ^ pMemoryProperties
                                                                                 -> IO ()
vkGetPhysicalDeviceMemoryProperties2Safe :: VkPhysicalDevice -> Ptr VkPhysicalDeviceMemoryProperties2 -> IO ()
vkGetPhysicalDeviceMemoryProperties2Safe
  = IO
  (VkPhysicalDevice
   -> Ptr VkPhysicalDeviceMemoryProperties2 -> IO ())
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceMemoryProperties2
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkGetPhysicalDeviceMemoryProperties2)

{-# NOINLINE vkGetPhysicalDeviceMemoryProperties2Safe #-}
#endif

-- |
-- > void vkGetPhysicalDeviceMemoryProperties2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , VkPhysicalDeviceMemoryProperties2* pMemoryProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceMemoryProperties2 <- vkGetInstanceProc @VkGetPhysicalDeviceMemoryProperties2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceMemoryProperties2 <- vkGetProc @VkGetPhysicalDeviceMemoryProperties2
--
-- __Note:__ @vkGetPhysicalDeviceMemoryProperties2Unsafe@ and @vkGetPhysicalDeviceMemoryProperties2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceMemoryProperties2@ is an alias
--           of @vkGetPhysicalDeviceMemoryProperties2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceMemoryProperties2Safe@.
--
vkGetPhysicalDeviceMemoryProperties2 ::
                                     VkPhysicalDevice -- ^ physicalDevice
                                                      ->
                                       Ptr VkPhysicalDeviceMemoryProperties2 -- ^ pMemoryProperties
                                                                             -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkGetPhysicalDeviceMemoryProperties2
  = vkGetPhysicalDeviceMemoryProperties2Unsafe
#else
vkGetPhysicalDeviceMemoryProperties2 :: VkPhysicalDevice -> Ptr VkPhysicalDeviceMemoryProperties2 -> IO ()
vkGetPhysicalDeviceMemoryProperties2
  = VkPhysicalDevice -> Ptr VkPhysicalDeviceMemoryProperties2 -> IO ()
vkGetPhysicalDeviceMemoryProperties2Safe

#endif
{-# INLINE vkGetPhysicalDeviceMemoryProperties2 #-}

-- | > void vkGetPhysicalDeviceMemoryProperties2
--   >     ( VkPhysicalDevice physicalDevice
--   >     , VkPhysicalDeviceMemoryProperties2* pMemoryProperties
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 registry at www.khronos.org>
type HS_vkGetPhysicalDeviceMemoryProperties2 =
     VkPhysicalDevice -- ^ physicalDevice
                      -> Ptr VkPhysicalDeviceMemoryProperties2 -- ^ pMemoryProperties
                                                               -> IO ()

type PFN_vkGetPhysicalDeviceMemoryProperties2 =
     FunPtr HS_vkGetPhysicalDeviceMemoryProperties2

foreign import ccall unsafe "dynamic"
               unwrapVkGetPhysicalDeviceMemoryProperties2Unsafe ::
               PFN_vkGetPhysicalDeviceMemoryProperties2 ->
                 HS_vkGetPhysicalDeviceMemoryProperties2

foreign import ccall safe "dynamic"
               unwrapVkGetPhysicalDeviceMemoryProperties2Safe ::
               PFN_vkGetPhysicalDeviceMemoryProperties2 ->
                 HS_vkGetPhysicalDeviceMemoryProperties2

instance VulkanProc "vkGetPhysicalDeviceMemoryProperties2" where
    type VkProcType "vkGetPhysicalDeviceMemoryProperties2" =
         HS_vkGetPhysicalDeviceMemoryProperties2
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkGetPhysicalDeviceMemoryProperties2

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkGetPhysicalDeviceMemoryProperties2)
-> VkProcType VkGetPhysicalDeviceMemoryProperties2
unwrapVkProcPtrUnsafe
      = FunPtr (VkProcType VkGetPhysicalDeviceMemoryProperties2)
-> VkProcType VkGetPhysicalDeviceMemoryProperties2
PFN_vkGetPhysicalDeviceMemoryProperties2
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceMemoryProperties2
-> IO ()
unwrapVkGetPhysicalDeviceMemoryProperties2Unsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkGetPhysicalDeviceMemoryProperties2)
-> VkProcType VkGetPhysicalDeviceMemoryProperties2
unwrapVkProcPtrSafe
      = FunPtr (VkProcType VkGetPhysicalDeviceMemoryProperties2)
-> VkProcType VkGetPhysicalDeviceMemoryProperties2
PFN_vkGetPhysicalDeviceMemoryProperties2
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceMemoryProperties2
-> IO ()
unwrapVkGetPhysicalDeviceMemoryProperties2Safe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VkGetPhysicalDeviceSparseImageFormatProperties2 :: CString

pattern $bVkGetPhysicalDeviceSparseImageFormatProperties2 :: CString
$mVkGetPhysicalDeviceSparseImageFormatProperties2 :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkGetPhysicalDeviceSparseImageFormatProperties2 <-
        (is_VkGetPhysicalDeviceSparseImageFormatProperties2 -> True)
  where
    VkGetPhysicalDeviceSparseImageFormatProperties2
      = CString
_VkGetPhysicalDeviceSparseImageFormatProperties2

{-# INLINE _VkGetPhysicalDeviceSparseImageFormatProperties2 #-}

_VkGetPhysicalDeviceSparseImageFormatProperties2 :: CString
_VkGetPhysicalDeviceSparseImageFormatProperties2 :: CString
_VkGetPhysicalDeviceSparseImageFormatProperties2
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkGetPhysicalDeviceSparseImageFormatProperties2\NUL"#

{-# INLINE is_VkGetPhysicalDeviceSparseImageFormatProperties2 #-}

is_VkGetPhysicalDeviceSparseImageFormatProperties2 ::
                                                   CString -> Bool
is_VkGetPhysicalDeviceSparseImageFormatProperties2 :: CString -> Bool
is_VkGetPhysicalDeviceSparseImageFormatProperties2
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      CString -> CString -> Ordering
cmpCStrings CString
_VkGetPhysicalDeviceSparseImageFormatProperties2

type VkGetPhysicalDeviceSparseImageFormatProperties2 =
     "vkGetPhysicalDeviceSparseImageFormatProperties2"

-- |
-- > void vkGetPhysicalDeviceSparseImageFormatProperties2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo
-- >     , uint32_t* pPropertyCount
-- >     , VkSparseImageFormatProperties2* pProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceSparseImageFormatProperties2 <- vkGetInstanceProc @VkGetPhysicalDeviceSparseImageFormatProperties2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceSparseImageFormatProperties2 <- vkGetProc @VkGetPhysicalDeviceSparseImageFormatProperties2
--
-- __Note:__ @vkGetPhysicalDeviceSparseImageFormatProperties2Unsafe@ and @vkGetPhysicalDeviceSparseImageFormatProperties2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceSparseImageFormatProperties2@ is an alias
--           of @vkGetPhysicalDeviceSparseImageFormatProperties2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceSparseImageFormatProperties2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe
               "vkGetPhysicalDeviceSparseImageFormatProperties2"
               vkGetPhysicalDeviceSparseImageFormatProperties2Unsafe ::
               VkPhysicalDevice -- ^ physicalDevice
                                ->
                 Ptr VkPhysicalDeviceSparseImageFormatInfo2 -- ^ pFormatInfo
                                                            ->
                   Ptr Word32 -- ^ pPropertyCount
                              -> Ptr VkSparseImageFormatProperties2 -- ^ pProperties
                                                                    -> IO ()

#else
vkGetPhysicalDeviceSparseImageFormatProperties2Unsafe ::
                                                      VkPhysicalDevice -- ^ physicalDevice
                                                                       ->
                                                        Ptr VkPhysicalDeviceSparseImageFormatInfo2 -- ^ pFormatInfo
                                                          ->
                                                          Ptr Word32 -- ^ pPropertyCount
                                                                     ->
                                                            Ptr VkSparseImageFormatProperties2 -- ^ pProperties
                                                                                               ->
                                                              IO ()
vkGetPhysicalDeviceSparseImageFormatProperties2Unsafe :: VkPhysicalDevice
-> Ptr VkPhysicalDeviceSparseImageFormatInfo2
-> Ptr Word32
-> Ptr VkSparseImageFormatProperties2
-> IO ()
vkGetPhysicalDeviceSparseImageFormatProperties2Unsafe
  = IO
  (VkPhysicalDevice
   -> Ptr VkPhysicalDeviceSparseImageFormatInfo2
   -> Ptr Word32
   -> Ptr VkSparseImageFormatProperties2
   -> IO ())
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceSparseImageFormatInfo2
-> Ptr Word32
-> Ptr VkSparseImageFormatProperties2
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkGetPhysicalDeviceSparseImageFormatProperties2)

{-# NOINLINE vkGetPhysicalDeviceSparseImageFormatProperties2Unsafe
             #-}
#endif

-- |
-- > void vkGetPhysicalDeviceSparseImageFormatProperties2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo
-- >     , uint32_t* pPropertyCount
-- >     , VkSparseImageFormatProperties2* pProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceSparseImageFormatProperties2 <- vkGetInstanceProc @VkGetPhysicalDeviceSparseImageFormatProperties2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceSparseImageFormatProperties2 <- vkGetProc @VkGetPhysicalDeviceSparseImageFormatProperties2
--
-- __Note:__ @vkGetPhysicalDeviceSparseImageFormatProperties2Unsafe@ and @vkGetPhysicalDeviceSparseImageFormatProperties2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceSparseImageFormatProperties2@ is an alias
--           of @vkGetPhysicalDeviceSparseImageFormatProperties2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceSparseImageFormatProperties2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe
               "vkGetPhysicalDeviceSparseImageFormatProperties2"
               vkGetPhysicalDeviceSparseImageFormatProperties2Safe ::
               VkPhysicalDevice -- ^ physicalDevice
                                ->
                 Ptr VkPhysicalDeviceSparseImageFormatInfo2 -- ^ pFormatInfo
                                                            ->
                   Ptr Word32 -- ^ pPropertyCount
                              -> Ptr VkSparseImageFormatProperties2 -- ^ pProperties
                                                                    -> IO ()

#else
vkGetPhysicalDeviceSparseImageFormatProperties2Safe ::
                                                    VkPhysicalDevice -- ^ physicalDevice
                                                                     ->
                                                      Ptr VkPhysicalDeviceSparseImageFormatInfo2 -- ^ pFormatInfo
                                                                                                 ->
                                                        Ptr Word32 -- ^ pPropertyCount
                                                                   ->
                                                          Ptr VkSparseImageFormatProperties2 -- ^ pProperties
                                                                                             ->
                                                            IO ()
vkGetPhysicalDeviceSparseImageFormatProperties2Safe :: VkPhysicalDevice
-> Ptr VkPhysicalDeviceSparseImageFormatInfo2
-> Ptr Word32
-> Ptr VkSparseImageFormatProperties2
-> IO ()
vkGetPhysicalDeviceSparseImageFormatProperties2Safe
  = IO
  (VkPhysicalDevice
   -> Ptr VkPhysicalDeviceSparseImageFormatInfo2
   -> Ptr Word32
   -> Ptr VkSparseImageFormatProperties2
   -> IO ())
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceSparseImageFormatInfo2
-> Ptr Word32
-> Ptr VkSparseImageFormatProperties2
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkGetPhysicalDeviceSparseImageFormatProperties2)

{-# NOINLINE vkGetPhysicalDeviceSparseImageFormatProperties2Safe
             #-}
#endif

-- |
-- > void vkGetPhysicalDeviceSparseImageFormatProperties2
-- >     ( VkPhysicalDevice physicalDevice
-- >     , const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo
-- >     , uint32_t* pPropertyCount
-- >     , VkSparseImageFormatProperties2* pProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceSparseImageFormatProperties2 <- vkGetInstanceProc @VkGetPhysicalDeviceSparseImageFormatProperties2 vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceSparseImageFormatProperties2 <- vkGetProc @VkGetPhysicalDeviceSparseImageFormatProperties2
--
-- __Note:__ @vkGetPhysicalDeviceSparseImageFormatProperties2Unsafe@ and @vkGetPhysicalDeviceSparseImageFormatProperties2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceSparseImageFormatProperties2@ is an alias
--           of @vkGetPhysicalDeviceSparseImageFormatProperties2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceSparseImageFormatProperties2Safe@.
--
vkGetPhysicalDeviceSparseImageFormatProperties2 ::
                                                VkPhysicalDevice -- ^ physicalDevice
                                                                 ->
                                                  Ptr VkPhysicalDeviceSparseImageFormatInfo2 -- ^ pFormatInfo
                                                                                             ->
                                                    Ptr Word32 -- ^ pPropertyCount
                                                               ->
                                                      Ptr VkSparseImageFormatProperties2 -- ^ pProperties
                                                                                         -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkGetPhysicalDeviceSparseImageFormatProperties2
  = vkGetPhysicalDeviceSparseImageFormatProperties2Unsafe
#else
vkGetPhysicalDeviceSparseImageFormatProperties2 :: VkPhysicalDevice
-> Ptr VkPhysicalDeviceSparseImageFormatInfo2
-> Ptr Word32
-> Ptr VkSparseImageFormatProperties2
-> IO ()
vkGetPhysicalDeviceSparseImageFormatProperties2
  = VkPhysicalDevice
-> Ptr VkPhysicalDeviceSparseImageFormatInfo2
-> Ptr Word32
-> Ptr VkSparseImageFormatProperties2
-> IO ()
vkGetPhysicalDeviceSparseImageFormatProperties2Safe

#endif
{-# INLINE vkGetPhysicalDeviceSparseImageFormatProperties2 #-}

-- | > void vkGetPhysicalDeviceSparseImageFormatProperties2
--   >     ( VkPhysicalDevice physicalDevice
--   >     , const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo
--   >     , uint32_t* pPropertyCount
--   >     , VkSparseImageFormatProperties2* pProperties
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 registry at www.khronos.org>
type HS_vkGetPhysicalDeviceSparseImageFormatProperties2 =
     VkPhysicalDevice -- ^ physicalDevice
                      ->
       Ptr VkPhysicalDeviceSparseImageFormatInfo2 -- ^ pFormatInfo
                                                  ->
         Ptr Word32 -- ^ pPropertyCount
                    -> Ptr VkSparseImageFormatProperties2 -- ^ pProperties
                                                          -> IO ()

type PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 =
     FunPtr HS_vkGetPhysicalDeviceSparseImageFormatProperties2

foreign import ccall unsafe "dynamic"
               unwrapVkGetPhysicalDeviceSparseImageFormatProperties2Unsafe ::
               PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 ->
                 HS_vkGetPhysicalDeviceSparseImageFormatProperties2

foreign import ccall safe "dynamic"
               unwrapVkGetPhysicalDeviceSparseImageFormatProperties2Safe ::
               PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 ->
                 HS_vkGetPhysicalDeviceSparseImageFormatProperties2

instance VulkanProc
           "vkGetPhysicalDeviceSparseImageFormatProperties2"
         where
    type VkProcType "vkGetPhysicalDeviceSparseImageFormatProperties2" =
         HS_vkGetPhysicalDeviceSparseImageFormatProperties2
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkGetPhysicalDeviceSparseImageFormatProperties2

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkGetPhysicalDeviceSparseImageFormatProperties2)
-> VkProcType VkGetPhysicalDeviceSparseImageFormatProperties2
unwrapVkProcPtrUnsafe
      = FunPtr (VkProcType VkGetPhysicalDeviceSparseImageFormatProperties2)
-> VkProcType VkGetPhysicalDeviceSparseImageFormatProperties2
PFN_vkGetPhysicalDeviceSparseImageFormatProperties2
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceSparseImageFormatInfo2
-> Ptr Word32
-> Ptr VkSparseImageFormatProperties2
-> IO ()
unwrapVkGetPhysicalDeviceSparseImageFormatProperties2Unsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkGetPhysicalDeviceSparseImageFormatProperties2)
-> VkProcType VkGetPhysicalDeviceSparseImageFormatProperties2
unwrapVkProcPtrSafe
      = FunPtr (VkProcType VkGetPhysicalDeviceSparseImageFormatProperties2)
-> VkProcType VkGetPhysicalDeviceSparseImageFormatProperties2
PFN_vkGetPhysicalDeviceSparseImageFormatProperties2
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceSparseImageFormatInfo2
-> Ptr Word32
-> Ptr VkSparseImageFormatProperties2
-> IO ()
unwrapVkGetPhysicalDeviceSparseImageFormatProperties2Safe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 =
        VkStructureType 1000059000

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 =
        VkStructureType 1000059001

pattern VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 :: VkStructureType
$mVK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 =
        VkStructureType 1000059002

pattern VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 :: VkStructureType
$mVK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 =
        VkStructureType 1000059003

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 =
        VkStructureType 1000059004

pattern VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 :: VkStructureType
$mVK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 =
        VkStructureType 1000059005

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 =
        VkStructureType 1000059006

pattern VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 :: VkStructureType
$mVK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 =
        VkStructureType 1000059007

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2
        :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2
        = VkStructureType 1000059008

pattern VkTrimCommandPool :: CString

pattern $bVkTrimCommandPool :: CString
$mVkTrimCommandPool :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkTrimCommandPool <- (is_VkTrimCommandPool -> True)
  where
    VkTrimCommandPool = CString
_VkTrimCommandPool

{-# INLINE _VkTrimCommandPool #-}

_VkTrimCommandPool :: CString
_VkTrimCommandPool :: CString
_VkTrimCommandPool = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkTrimCommandPool\NUL"#

{-# INLINE is_VkTrimCommandPool #-}

is_VkTrimCommandPool :: CString -> Bool
is_VkTrimCommandPool :: CString -> Bool
is_VkTrimCommandPool = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkTrimCommandPool

type VkTrimCommandPool = "vkTrimCommandPool"

-- |
-- > void vkTrimCommandPool
-- >     ( VkDevice device
-- >     , VkCommandPool commandPool
-- >     , VkCommandPoolTrimFlags flags
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkTrimCommandPool vkTrimCommandPool registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myTrimCommandPool <- vkGetDeviceProc @VkTrimCommandPool vkDevice
--
-- or less efficient:
--
-- > myTrimCommandPool <- vkGetProc @VkTrimCommandPool
--
-- __Note:__ @vkTrimCommandPoolUnsafe@ and @vkTrimCommandPoolSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkTrimCommandPool@ is an alias
--           of @vkTrimCommandPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkTrimCommandPoolSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkTrimCommandPool"
               vkTrimCommandPoolUnsafe ::
               VkDevice -- ^ device
                        -> VkCommandPool -- ^ commandPool
                                         -> VkCommandPoolTrimFlags -- ^ flags
                                                                   -> IO ()

#else
vkTrimCommandPoolUnsafe ::
                        VkDevice -- ^ device
                                 -> VkCommandPool -- ^ commandPool
                                                  -> VkCommandPoolTrimFlags -- ^ flags
                                                                            -> IO ()
vkTrimCommandPoolUnsafe :: VkDevice -> VkCommandPool -> VkCommandPoolTrimFlags -> IO ()
vkTrimCommandPoolUnsafe
  = IO (VkDevice -> VkCommandPool -> VkCommandPoolTrimFlags -> IO ())
-> VkDevice -> VkCommandPool -> VkCommandPoolTrimFlags -> IO ()
forall a. IO a -> a
unsafeDupablePerformIO (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkTrimCommandPool)

{-# NOINLINE vkTrimCommandPoolUnsafe #-}
#endif

-- |
-- > void vkTrimCommandPool
-- >     ( VkDevice device
-- >     , VkCommandPool commandPool
-- >     , VkCommandPoolTrimFlags flags
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkTrimCommandPool vkTrimCommandPool registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myTrimCommandPool <- vkGetDeviceProc @VkTrimCommandPool vkDevice
--
-- or less efficient:
--
-- > myTrimCommandPool <- vkGetProc @VkTrimCommandPool
--
-- __Note:__ @vkTrimCommandPoolUnsafe@ and @vkTrimCommandPoolSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkTrimCommandPool@ is an alias
--           of @vkTrimCommandPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkTrimCommandPoolSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkTrimCommandPool" vkTrimCommandPoolSafe
               :: VkDevice -- ^ device
                           -> VkCommandPool -- ^ commandPool
                                            -> VkCommandPoolTrimFlags -- ^ flags
                                                                      -> IO ()

#else
vkTrimCommandPoolSafe ::
                      VkDevice -- ^ device
                               -> VkCommandPool -- ^ commandPool
                                                -> VkCommandPoolTrimFlags -- ^ flags
                                                                          -> IO ()
vkTrimCommandPoolSafe :: VkDevice -> VkCommandPool -> VkCommandPoolTrimFlags -> IO ()
vkTrimCommandPoolSafe
  = IO (VkDevice -> VkCommandPool -> VkCommandPoolTrimFlags -> IO ())
-> VkDevice -> VkCommandPool -> VkCommandPoolTrimFlags -> IO ()
forall a. IO a -> a
unsafeDupablePerformIO (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkTrimCommandPool)

{-# NOINLINE vkTrimCommandPoolSafe #-}
#endif

-- |
-- > void vkTrimCommandPool
-- >     ( VkDevice device
-- >     , VkCommandPool commandPool
-- >     , VkCommandPoolTrimFlags flags
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkTrimCommandPool vkTrimCommandPool registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myTrimCommandPool <- vkGetDeviceProc @VkTrimCommandPool vkDevice
--
-- or less efficient:
--
-- > myTrimCommandPool <- vkGetProc @VkTrimCommandPool
--
-- __Note:__ @vkTrimCommandPoolUnsafe@ and @vkTrimCommandPoolSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkTrimCommandPool@ is an alias
--           of @vkTrimCommandPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkTrimCommandPoolSafe@.
--
vkTrimCommandPool ::
                  VkDevice -- ^ device
                           -> VkCommandPool -- ^ commandPool
                                            -> VkCommandPoolTrimFlags -- ^ flags
                                                                      -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkTrimCommandPool = vkTrimCommandPoolUnsafe
#else
vkTrimCommandPool :: VkDevice -> VkCommandPool -> VkCommandPoolTrimFlags -> IO ()
vkTrimCommandPool = VkDevice -> VkCommandPool -> VkCommandPoolTrimFlags -> IO ()
vkTrimCommandPoolSafe

#endif
{-# INLINE vkTrimCommandPool #-}

-- | > void vkTrimCommandPool
--   >     ( VkDevice device
--   >     , VkCommandPool commandPool
--   >     , VkCommandPoolTrimFlags flags
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkTrimCommandPool vkTrimCommandPool registry at www.khronos.org>
type HS_vkTrimCommandPool =
     VkDevice -- ^ device
              -> VkCommandPool -- ^ commandPool
                               -> VkCommandPoolTrimFlags -- ^ flags
                                                         -> IO ()

type PFN_vkTrimCommandPool = FunPtr HS_vkTrimCommandPool

foreign import ccall unsafe "dynamic" unwrapVkTrimCommandPoolUnsafe
               :: PFN_vkTrimCommandPool -> HS_vkTrimCommandPool

foreign import ccall safe "dynamic" unwrapVkTrimCommandPoolSafe ::
               PFN_vkTrimCommandPool -> HS_vkTrimCommandPool

instance VulkanProc "vkTrimCommandPool" where
    type VkProcType "vkTrimCommandPool" = HS_vkTrimCommandPool
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkTrimCommandPool

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkTrimCommandPool)
-> VkProcType VkTrimCommandPool
unwrapVkProcPtrUnsafe = FunPtr (VkProcType VkTrimCommandPool)
-> VkProcType VkTrimCommandPool
PFN_vkTrimCommandPool
-> VkDevice -> VkCommandPool -> VkCommandPoolTrimFlags -> IO ()
unwrapVkTrimCommandPoolUnsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkTrimCommandPool)
-> VkProcType VkTrimCommandPool
unwrapVkProcPtrSafe = FunPtr (VkProcType VkTrimCommandPool)
-> VkProcType VkTrimCommandPool
PFN_vkTrimCommandPool
-> VkDevice -> VkCommandPool -> VkCommandPoolTrimFlags -> IO ()
unwrapVkTrimCommandPoolSafe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VK_ERROR_OUT_OF_POOL_MEMORY :: VkResult

pattern $bVK_ERROR_OUT_OF_POOL_MEMORY :: VkResult
$mVK_ERROR_OUT_OF_POOL_MEMORY :: forall {r}. VkResult -> (Void# -> r) -> (Void# -> r) -> r
VK_ERROR_OUT_OF_POOL_MEMORY = VkResult (-1000069000)

-- | Format can be used as the source image of image transfer commands
--
--   bitpos = @14@
pattern VK_FORMAT_FEATURE_TRANSFER_SRC_BIT ::
        VkFormatFeatureBitmask a

pattern $bVK_FORMAT_FEATURE_TRANSFER_SRC_BIT :: forall (a :: FlagType). VkFormatFeatureBitmask a
$mVK_FORMAT_FEATURE_TRANSFER_SRC_BIT :: forall {r} {a :: FlagType}.
VkFormatFeatureBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_FEATURE_TRANSFER_SRC_BIT =
        VkFormatFeatureBitmask 16384

-- | Format can be used as the destination image of image transfer commands
--
--   bitpos = @15@
pattern VK_FORMAT_FEATURE_TRANSFER_DST_BIT ::
        VkFormatFeatureBitmask a

pattern $bVK_FORMAT_FEATURE_TRANSFER_DST_BIT :: forall (a :: FlagType). VkFormatFeatureBitmask a
$mVK_FORMAT_FEATURE_TRANSFER_DST_BIT :: forall {r} {a :: FlagType}.
VkFormatFeatureBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_FEATURE_TRANSFER_DST_BIT =
        VkFormatFeatureBitmask 32768

-- | The 3D image can be viewed as a 2D or 2D array image
--
--   bitpos = @5@
pattern VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT ::
        VkImageCreateBitmask a

pattern $bVK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT :: forall (a :: FlagType). VkImageCreateBitmask a
$mVK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT :: forall {r} {a :: FlagType}.
VkImageCreateBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT =
        VkImageCreateBitmask 32

-- | bitpos = @7@
pattern VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT ::
        VkImageCreateBitmask a

pattern $bVK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT :: forall (a :: FlagType). VkImageCreateBitmask a
$mVK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT :: forall {r} {a :: FlagType}.
VkImageCreateBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT =
        VkImageCreateBitmask 128

-- | bitpos = @8@
pattern VK_IMAGE_CREATE_EXTENDED_USAGE_BIT ::
        VkImageCreateBitmask a

pattern $bVK_IMAGE_CREATE_EXTENDED_USAGE_BIT :: forall (a :: FlagType). VkImageCreateBitmask a
$mVK_IMAGE_CREATE_EXTENDED_USAGE_BIT :: forall {r} {a :: FlagType}.
VkImageCreateBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_IMAGE_CREATE_EXTENDED_USAGE_BIT =
        VkImageCreateBitmask 256

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES
        :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES
        = VkStructureType 1000117000

pattern VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO
        :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO
        = VkStructureType 1000117001

pattern VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO =
        VkStructureType 1000117002

pattern VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO
        :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO
        = VkStructureType 1000117003

pattern VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
        :: VkImageLayout

pattern $bVK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL :: VkImageLayout
$mVK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL :: forall {r}. VkImageLayout -> (Void# -> r) -> (Void# -> r) -> r
VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
        = VkImageLayout 1000117000

pattern VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
        :: VkImageLayout

pattern $bVK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL :: VkImageLayout
$mVK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL :: forall {r}. VkImageLayout -> (Void# -> r) -> (Void# -> r) -> r
VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
        = VkImageLayout 1000117001

pattern VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO =
        VkStructureType 1000053000

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES =
        VkStructureType 1000053001

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES =
        VkStructureType 1000053002

-- | bitpos = @1@
pattern VK_DEPENDENCY_VIEW_LOCAL_BIT :: VkDependencyBitmask a

pattern $bVK_DEPENDENCY_VIEW_LOCAL_BIT :: forall (a :: FlagType). VkDependencyBitmask a
$mVK_DEPENDENCY_VIEW_LOCAL_BIT :: forall {r} {a :: FlagType}.
VkDependencyBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_DEPENDENCY_VIEW_LOCAL_BIT = VkDependencyBitmask 2

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES
        :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES
        = VkStructureType 1000120000

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES
        = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES

pattern VkGetDeviceQueue2 :: CString

pattern $bVkGetDeviceQueue2 :: CString
$mVkGetDeviceQueue2 :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkGetDeviceQueue2 <- (is_VkGetDeviceQueue2 -> True)
  where
    VkGetDeviceQueue2 = CString
_VkGetDeviceQueue2

{-# INLINE _VkGetDeviceQueue2 #-}

_VkGetDeviceQueue2 :: CString
_VkGetDeviceQueue2 :: CString
_VkGetDeviceQueue2 = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkGetDeviceQueue2\NUL"#

{-# INLINE is_VkGetDeviceQueue2 #-}

is_VkGetDeviceQueue2 :: CString -> Bool
is_VkGetDeviceQueue2 :: CString -> Bool
is_VkGetDeviceQueue2 = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkGetDeviceQueue2

type VkGetDeviceQueue2 = "vkGetDeviceQueue2"

-- |
-- > void vkGetDeviceQueue2
-- >     ( VkDevice device
-- >     , const VkDeviceQueueInfo2* pQueueInfo
-- >     , VkQueue* pQueue
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceQueue2 vkGetDeviceQueue2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetDeviceQueue2 <- vkGetDeviceProc @VkGetDeviceQueue2 vkDevice
--
-- or less efficient:
--
-- > myGetDeviceQueue2 <- vkGetProc @VkGetDeviceQueue2
--
-- __Note:__ @vkGetDeviceQueue2Unsafe@ and @vkGetDeviceQueue2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetDeviceQueue2@ is an alias
--           of @vkGetDeviceQueue2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetDeviceQueue2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkGetDeviceQueue2"
               vkGetDeviceQueue2Unsafe ::
               VkDevice -- ^ device
                        -> Ptr VkDeviceQueueInfo2 -- ^ pQueueInfo
                                                  -> Ptr VkQueue -- ^ pQueue
                                                                 -> IO ()

#else
vkGetDeviceQueue2Unsafe ::
                        VkDevice -- ^ device
                                 -> Ptr VkDeviceQueueInfo2 -- ^ pQueueInfo
                                                           -> Ptr VkQueue -- ^ pQueue
                                                                          -> IO ()
vkGetDeviceQueue2Unsafe :: VkDevice -> Ptr VkDeviceQueueInfo2 -> Ptr VkQueue -> IO ()
vkGetDeviceQueue2Unsafe
  = IO (VkDevice -> Ptr VkDeviceQueueInfo2 -> Ptr VkQueue -> IO ())
-> VkDevice -> Ptr VkDeviceQueueInfo2 -> Ptr VkQueue -> IO ()
forall a. IO a -> a
unsafeDupablePerformIO (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkGetDeviceQueue2)

{-# NOINLINE vkGetDeviceQueue2Unsafe #-}
#endif

-- |
-- > void vkGetDeviceQueue2
-- >     ( VkDevice device
-- >     , const VkDeviceQueueInfo2* pQueueInfo
-- >     , VkQueue* pQueue
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceQueue2 vkGetDeviceQueue2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetDeviceQueue2 <- vkGetDeviceProc @VkGetDeviceQueue2 vkDevice
--
-- or less efficient:
--
-- > myGetDeviceQueue2 <- vkGetProc @VkGetDeviceQueue2
--
-- __Note:__ @vkGetDeviceQueue2Unsafe@ and @vkGetDeviceQueue2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetDeviceQueue2@ is an alias
--           of @vkGetDeviceQueue2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetDeviceQueue2Safe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkGetDeviceQueue2" vkGetDeviceQueue2Safe
               :: VkDevice -- ^ device
                           -> Ptr VkDeviceQueueInfo2 -- ^ pQueueInfo
                                                     -> Ptr VkQueue -- ^ pQueue
                                                                    -> IO ()

#else
vkGetDeviceQueue2Safe ::
                      VkDevice -- ^ device
                               -> Ptr VkDeviceQueueInfo2 -- ^ pQueueInfo
                                                         -> Ptr VkQueue -- ^ pQueue
                                                                        -> IO ()
vkGetDeviceQueue2Safe :: VkDevice -> Ptr VkDeviceQueueInfo2 -> Ptr VkQueue -> IO ()
vkGetDeviceQueue2Safe
  = IO (VkDevice -> Ptr VkDeviceQueueInfo2 -> Ptr VkQueue -> IO ())
-> VkDevice -> Ptr VkDeviceQueueInfo2 -> Ptr VkQueue -> IO ()
forall a. IO a -> a
unsafeDupablePerformIO (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkGetDeviceQueue2)

{-# NOINLINE vkGetDeviceQueue2Safe #-}
#endif

-- |
-- > void vkGetDeviceQueue2
-- >     ( VkDevice device
-- >     , const VkDeviceQueueInfo2* pQueueInfo
-- >     , VkQueue* pQueue
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceQueue2 vkGetDeviceQueue2 registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetDeviceQueue2 <- vkGetDeviceProc @VkGetDeviceQueue2 vkDevice
--
-- or less efficient:
--
-- > myGetDeviceQueue2 <- vkGetProc @VkGetDeviceQueue2
--
-- __Note:__ @vkGetDeviceQueue2Unsafe@ and @vkGetDeviceQueue2Safe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetDeviceQueue2@ is an alias
--           of @vkGetDeviceQueue2Unsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetDeviceQueue2Safe@.
--
vkGetDeviceQueue2 ::
                  VkDevice -- ^ device
                           -> Ptr VkDeviceQueueInfo2 -- ^ pQueueInfo
                                                     -> Ptr VkQueue -- ^ pQueue
                                                                    -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkGetDeviceQueue2 = vkGetDeviceQueue2Unsafe
#else
vkGetDeviceQueue2 :: VkDevice -> Ptr VkDeviceQueueInfo2 -> Ptr VkQueue -> IO ()
vkGetDeviceQueue2 = VkDevice -> Ptr VkDeviceQueueInfo2 -> Ptr VkQueue -> IO ()
vkGetDeviceQueue2Safe

#endif
{-# INLINE vkGetDeviceQueue2 #-}

-- | > void vkGetDeviceQueue2
--   >     ( VkDevice device
--   >     , const VkDeviceQueueInfo2* pQueueInfo
--   >     , VkQueue* pQueue
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceQueue2 vkGetDeviceQueue2 registry at www.khronos.org>
type HS_vkGetDeviceQueue2 =
     VkDevice -- ^ device
              -> Ptr VkDeviceQueueInfo2 -- ^ pQueueInfo
                                        -> Ptr VkQueue -- ^ pQueue
                                                       -> IO ()

type PFN_vkGetDeviceQueue2 = FunPtr HS_vkGetDeviceQueue2

foreign import ccall unsafe "dynamic" unwrapVkGetDeviceQueue2Unsafe
               :: PFN_vkGetDeviceQueue2 -> HS_vkGetDeviceQueue2

foreign import ccall safe "dynamic" unwrapVkGetDeviceQueue2Safe ::
               PFN_vkGetDeviceQueue2 -> HS_vkGetDeviceQueue2

instance VulkanProc "vkGetDeviceQueue2" where
    type VkProcType "vkGetDeviceQueue2" = HS_vkGetDeviceQueue2
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkGetDeviceQueue2

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkGetDeviceQueue2)
-> VkProcType VkGetDeviceQueue2
unwrapVkProcPtrUnsafe = FunPtr (VkProcType VkGetDeviceQueue2)
-> VkProcType VkGetDeviceQueue2
PFN_vkGetDeviceQueue2
-> VkDevice -> Ptr VkDeviceQueueInfo2 -> Ptr VkQueue -> IO ()
unwrapVkGetDeviceQueue2Unsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkGetDeviceQueue2)
-> VkProcType VkGetDeviceQueue2
unwrapVkProcPtrSafe = FunPtr (VkProcType VkGetDeviceQueue2)
-> VkProcType VkGetDeviceQueue2
PFN_vkGetDeviceQueue2
-> VkDevice -> Ptr VkDeviceQueueInfo2 -> Ptr VkQueue -> IO ()
unwrapVkGetDeviceQueue2Safe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO =
        VkStructureType 1000145000

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES
        :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES
        = VkStructureType 1000145001

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES
        :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES
        = VkStructureType 1000145002

pattern VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 :: VkStructureType
$mVK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 =
        VkStructureType 1000145003

-- | Queues may support protected operations
--
--   bitpos = @4@
pattern VK_QUEUE_PROTECTED_BIT :: VkQueueBitmask a

pattern $bVK_QUEUE_PROTECTED_BIT :: forall (a :: FlagType). VkQueueBitmask a
$mVK_QUEUE_PROTECTED_BIT :: forall {r} {a :: FlagType}.
VkQueueBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_QUEUE_PROTECTED_BIT = VkQueueBitmask 16

-- | Queue is a protected-capable device queue
--
--   bitpos = @0@
pattern VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT ::
        VkDeviceQueueCreateBitmask a

pattern $bVK_DEVICE_QUEUE_CREATE_PROTECTED_BIT :: forall (a :: FlagType). VkDeviceQueueCreateBitmask a
$mVK_DEVICE_QUEUE_CREATE_PROTECTED_BIT :: forall {r} {a :: FlagType}.
VkDeviceQueueCreateBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT =
        VkDeviceQueueCreateBitmask 1

-- | Memory is protected
--
--   bitpos = @5@
pattern VK_MEMORY_PROPERTY_PROTECTED_BIT ::
        VkMemoryPropertyBitmask a

pattern $bVK_MEMORY_PROPERTY_PROTECTED_BIT :: forall (a :: FlagType). VkMemoryPropertyBitmask a
$mVK_MEMORY_PROPERTY_PROTECTED_BIT :: forall {r} {a :: FlagType}.
VkMemoryPropertyBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_MEMORY_PROPERTY_PROTECTED_BIT =
        VkMemoryPropertyBitmask 32

-- | Buffer requires protected memory
--
--   bitpos = @3@
pattern VK_BUFFER_CREATE_PROTECTED_BIT :: VkBufferCreateBitmask a

pattern $bVK_BUFFER_CREATE_PROTECTED_BIT :: forall (a :: FlagType). VkBufferCreateBitmask a
$mVK_BUFFER_CREATE_PROTECTED_BIT :: forall {r} {a :: FlagType}.
VkBufferCreateBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_BUFFER_CREATE_PROTECTED_BIT = VkBufferCreateBitmask 8

-- | Image requires protected memory
--
--   bitpos = @11@
pattern VK_IMAGE_CREATE_PROTECTED_BIT :: VkImageCreateBitmask a

pattern $bVK_IMAGE_CREATE_PROTECTED_BIT :: forall (a :: FlagType). VkImageCreateBitmask a
$mVK_IMAGE_CREATE_PROTECTED_BIT :: forall {r} {a :: FlagType}.
VkImageCreateBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_IMAGE_CREATE_PROTECTED_BIT = VkImageCreateBitmask 2048

-- | Command buffers allocated from pool are protected command buffers
--
--   bitpos = @2@
pattern VK_COMMAND_POOL_CREATE_PROTECTED_BIT ::
        VkCommandPoolCreateBitmask a

pattern $bVK_COMMAND_POOL_CREATE_PROTECTED_BIT :: forall (a :: FlagType). VkCommandPoolCreateBitmask a
$mVK_COMMAND_POOL_CREATE_PROTECTED_BIT :: forall {r} {a :: FlagType}.
VkCommandPoolCreateBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_POOL_CREATE_PROTECTED_BIT =
        VkCommandPoolCreateBitmask 4

pattern VkCreateSamplerYcbcrConversion :: CString

pattern $bVkCreateSamplerYcbcrConversion :: CString
$mVkCreateSamplerYcbcrConversion :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkCreateSamplerYcbcrConversion <-
        (is_VkCreateSamplerYcbcrConversion -> True)
  where
    VkCreateSamplerYcbcrConversion = CString
_VkCreateSamplerYcbcrConversion

{-# INLINE _VkCreateSamplerYcbcrConversion #-}

_VkCreateSamplerYcbcrConversion :: CString
_VkCreateSamplerYcbcrConversion :: CString
_VkCreateSamplerYcbcrConversion
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkCreateSamplerYcbcrConversion\NUL"#

{-# INLINE is_VkCreateSamplerYcbcrConversion #-}

is_VkCreateSamplerYcbcrConversion :: CString -> Bool
is_VkCreateSamplerYcbcrConversion :: CString -> Bool
is_VkCreateSamplerYcbcrConversion
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkCreateSamplerYcbcrConversion

type VkCreateSamplerYcbcrConversion =
     "vkCreateSamplerYcbcrConversion"

-- |
-- Success codes: 'VK_SUCCESS'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'.
--
-- > VkResult vkCreateSamplerYcbcrConversion
-- >     ( VkDevice device
-- >     , const VkSamplerYcbcrConversionCreateInfo* pCreateInfo
-- >     , const VkAllocationCallbacks* pAllocator
-- >     , VkSamplerYcbcrConversion* pYcbcrConversion
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myCreateSamplerYcbcrConversion <- vkGetDeviceProc @VkCreateSamplerYcbcrConversion vkDevice
--
-- or less efficient:
--
-- > myCreateSamplerYcbcrConversion <- vkGetProc @VkCreateSamplerYcbcrConversion
--
-- __Note:__ @vkCreateSamplerYcbcrConversionUnsafe@ and @vkCreateSamplerYcbcrConversionSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkCreateSamplerYcbcrConversion@ is an alias
--           of @vkCreateSamplerYcbcrConversionUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkCreateSamplerYcbcrConversionSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkCreateSamplerYcbcrConversion"
               vkCreateSamplerYcbcrConversionUnsafe ::
               VkDevice -- ^ device
                        ->
                 Ptr VkSamplerYcbcrConversionCreateInfo -- ^ pCreateInfo
                                                        ->
                   Ptr VkAllocationCallbacks -- ^ pAllocator
                                             ->
                     Ptr VkSamplerYcbcrConversion -- ^ pYcbcrConversion
                                                  -> IO VkResult

#else
vkCreateSamplerYcbcrConversionUnsafe ::
                                     VkDevice -- ^ device
                                              ->
                                       Ptr VkSamplerYcbcrConversionCreateInfo -- ^ pCreateInfo
                                                                              ->
                                         Ptr VkAllocationCallbacks -- ^ pAllocator
                                                                   ->
                                           Ptr VkSamplerYcbcrConversion -- ^ pYcbcrConversion
                                                                        -> IO VkResult
vkCreateSamplerYcbcrConversionUnsafe :: VkDevice
-> Ptr VkSamplerYcbcrConversionCreateInfo
-> Ptr VkAllocationCallbacks
-> Ptr VkSamplerYcbcrConversion
-> IO VkResult
vkCreateSamplerYcbcrConversionUnsafe
  = IO
  (VkDevice
   -> Ptr VkSamplerYcbcrConversionCreateInfo
   -> Ptr VkAllocationCallbacks
   -> Ptr VkSamplerYcbcrConversion
   -> IO VkResult)
-> VkDevice
-> Ptr VkSamplerYcbcrConversionCreateInfo
-> Ptr VkAllocationCallbacks
-> Ptr VkSamplerYcbcrConversion
-> IO VkResult
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkCreateSamplerYcbcrConversion)

{-# NOINLINE vkCreateSamplerYcbcrConversionUnsafe #-}
#endif

-- |
-- Success codes: 'VK_SUCCESS'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'.
--
-- > VkResult vkCreateSamplerYcbcrConversion
-- >     ( VkDevice device
-- >     , const VkSamplerYcbcrConversionCreateInfo* pCreateInfo
-- >     , const VkAllocationCallbacks* pAllocator
-- >     , VkSamplerYcbcrConversion* pYcbcrConversion
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myCreateSamplerYcbcrConversion <- vkGetDeviceProc @VkCreateSamplerYcbcrConversion vkDevice
--
-- or less efficient:
--
-- > myCreateSamplerYcbcrConversion <- vkGetProc @VkCreateSamplerYcbcrConversion
--
-- __Note:__ @vkCreateSamplerYcbcrConversionUnsafe@ and @vkCreateSamplerYcbcrConversionSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkCreateSamplerYcbcrConversion@ is an alias
--           of @vkCreateSamplerYcbcrConversionUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkCreateSamplerYcbcrConversionSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkCreateSamplerYcbcrConversion"
               vkCreateSamplerYcbcrConversionSafe ::
               VkDevice -- ^ device
                        ->
                 Ptr VkSamplerYcbcrConversionCreateInfo -- ^ pCreateInfo
                                                        ->
                   Ptr VkAllocationCallbacks -- ^ pAllocator
                                             ->
                     Ptr VkSamplerYcbcrConversion -- ^ pYcbcrConversion
                                                  -> IO VkResult

#else
vkCreateSamplerYcbcrConversionSafe ::
                                   VkDevice -- ^ device
                                            ->
                                     Ptr VkSamplerYcbcrConversionCreateInfo -- ^ pCreateInfo
                                                                            ->
                                       Ptr VkAllocationCallbacks -- ^ pAllocator
                                                                 ->
                                         Ptr VkSamplerYcbcrConversion -- ^ pYcbcrConversion
                                                                      -> IO VkResult
vkCreateSamplerYcbcrConversionSafe :: VkDevice
-> Ptr VkSamplerYcbcrConversionCreateInfo
-> Ptr VkAllocationCallbacks
-> Ptr VkSamplerYcbcrConversion
-> IO VkResult
vkCreateSamplerYcbcrConversionSafe
  = IO
  (VkDevice
   -> Ptr VkSamplerYcbcrConversionCreateInfo
   -> Ptr VkAllocationCallbacks
   -> Ptr VkSamplerYcbcrConversion
   -> IO VkResult)
-> VkDevice
-> Ptr VkSamplerYcbcrConversionCreateInfo
-> Ptr VkAllocationCallbacks
-> Ptr VkSamplerYcbcrConversion
-> IO VkResult
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkCreateSamplerYcbcrConversion)

{-# NOINLINE vkCreateSamplerYcbcrConversionSafe #-}
#endif

-- |
-- Success codes: 'VK_SUCCESS'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'.
--
-- > VkResult vkCreateSamplerYcbcrConversion
-- >     ( VkDevice device
-- >     , const VkSamplerYcbcrConversionCreateInfo* pCreateInfo
-- >     , const VkAllocationCallbacks* pAllocator
-- >     , VkSamplerYcbcrConversion* pYcbcrConversion
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myCreateSamplerYcbcrConversion <- vkGetDeviceProc @VkCreateSamplerYcbcrConversion vkDevice
--
-- or less efficient:
--
-- > myCreateSamplerYcbcrConversion <- vkGetProc @VkCreateSamplerYcbcrConversion
--
-- __Note:__ @vkCreateSamplerYcbcrConversionUnsafe@ and @vkCreateSamplerYcbcrConversionSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkCreateSamplerYcbcrConversion@ is an alias
--           of @vkCreateSamplerYcbcrConversionUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkCreateSamplerYcbcrConversionSafe@.
--
vkCreateSamplerYcbcrConversion ::
                               VkDevice -- ^ device
                                        ->
                                 Ptr VkSamplerYcbcrConversionCreateInfo -- ^ pCreateInfo
                                                                        ->
                                   Ptr VkAllocationCallbacks -- ^ pAllocator
                                                             ->
                                     Ptr VkSamplerYcbcrConversion -- ^ pYcbcrConversion
                                                                  -> IO VkResult
#ifdef UNSAFE_FFI_DEFAULT
vkCreateSamplerYcbcrConversion
  = vkCreateSamplerYcbcrConversionUnsafe
#else
vkCreateSamplerYcbcrConversion :: VkDevice
-> Ptr VkSamplerYcbcrConversionCreateInfo
-> Ptr VkAllocationCallbacks
-> Ptr VkSamplerYcbcrConversion
-> IO VkResult
vkCreateSamplerYcbcrConversion = VkDevice
-> Ptr VkSamplerYcbcrConversionCreateInfo
-> Ptr VkAllocationCallbacks
-> Ptr VkSamplerYcbcrConversion
-> IO VkResult
vkCreateSamplerYcbcrConversionSafe

#endif
{-# INLINE vkCreateSamplerYcbcrConversion #-}

-- | Success codes: 'VK_SUCCESS'.
--
--   Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'.
--
--   > VkResult vkCreateSamplerYcbcrConversion
--   >     ( VkDevice device
--   >     , const VkSamplerYcbcrConversionCreateInfo* pCreateInfo
--   >     , const VkAllocationCallbacks* pAllocator
--   >     , VkSamplerYcbcrConversion* pYcbcrConversion
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion registry at www.khronos.org>
type HS_vkCreateSamplerYcbcrConversion =
     VkDevice -- ^ device
              ->
       Ptr VkSamplerYcbcrConversionCreateInfo -- ^ pCreateInfo
                                              ->
         Ptr VkAllocationCallbacks -- ^ pAllocator
                                   ->
           Ptr VkSamplerYcbcrConversion -- ^ pYcbcrConversion
                                        -> IO VkResult

type PFN_vkCreateSamplerYcbcrConversion =
     FunPtr HS_vkCreateSamplerYcbcrConversion

foreign import ccall unsafe "dynamic"
               unwrapVkCreateSamplerYcbcrConversionUnsafe ::
               PFN_vkCreateSamplerYcbcrConversion ->
                 HS_vkCreateSamplerYcbcrConversion

foreign import ccall safe "dynamic"
               unwrapVkCreateSamplerYcbcrConversionSafe ::
               PFN_vkCreateSamplerYcbcrConversion ->
                 HS_vkCreateSamplerYcbcrConversion

instance VulkanProc "vkCreateSamplerYcbcrConversion" where
    type VkProcType "vkCreateSamplerYcbcrConversion" =
         HS_vkCreateSamplerYcbcrConversion
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkCreateSamplerYcbcrConversion

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkCreateSamplerYcbcrConversion)
-> VkProcType VkCreateSamplerYcbcrConversion
unwrapVkProcPtrUnsafe = FunPtr (VkProcType VkCreateSamplerYcbcrConversion)
-> VkProcType VkCreateSamplerYcbcrConversion
PFN_vkCreateSamplerYcbcrConversion
-> VkDevice
-> Ptr VkSamplerYcbcrConversionCreateInfo
-> Ptr VkAllocationCallbacks
-> Ptr VkSamplerYcbcrConversion
-> IO VkResult
unwrapVkCreateSamplerYcbcrConversionUnsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkCreateSamplerYcbcrConversion)
-> VkProcType VkCreateSamplerYcbcrConversion
unwrapVkProcPtrSafe = FunPtr (VkProcType VkCreateSamplerYcbcrConversion)
-> VkProcType VkCreateSamplerYcbcrConversion
PFN_vkCreateSamplerYcbcrConversion
-> VkDevice
-> Ptr VkSamplerYcbcrConversionCreateInfo
-> Ptr VkAllocationCallbacks
-> Ptr VkSamplerYcbcrConversion
-> IO VkResult
unwrapVkCreateSamplerYcbcrConversionSafe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VkDestroySamplerYcbcrConversion :: CString

pattern $bVkDestroySamplerYcbcrConversion :: CString
$mVkDestroySamplerYcbcrConversion :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkDestroySamplerYcbcrConversion <-
        (is_VkDestroySamplerYcbcrConversion -> True)
  where
    VkDestroySamplerYcbcrConversion = CString
_VkDestroySamplerYcbcrConversion

{-# INLINE _VkDestroySamplerYcbcrConversion #-}

_VkDestroySamplerYcbcrConversion :: CString
_VkDestroySamplerYcbcrConversion :: CString
_VkDestroySamplerYcbcrConversion
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkDestroySamplerYcbcrConversion\NUL"#

{-# INLINE is_VkDestroySamplerYcbcrConversion #-}

is_VkDestroySamplerYcbcrConversion :: CString -> Bool
is_VkDestroySamplerYcbcrConversion :: CString -> Bool
is_VkDestroySamplerYcbcrConversion
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkDestroySamplerYcbcrConversion

type VkDestroySamplerYcbcrConversion =
     "vkDestroySamplerYcbcrConversion"

-- |
-- > void vkDestroySamplerYcbcrConversion
-- >     ( VkDevice device
-- >     , VkSamplerYcbcrConversion ycbcrConversion
-- >     , const VkAllocationCallbacks* pAllocator
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myDestroySamplerYcbcrConversion <- vkGetDeviceProc @VkDestroySamplerYcbcrConversion vkDevice
--
-- or less efficient:
--
-- > myDestroySamplerYcbcrConversion <- vkGetProc @VkDestroySamplerYcbcrConversion
--
-- __Note:__ @vkDestroySamplerYcbcrConversionUnsafe@ and @vkDestroySamplerYcbcrConversionSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkDestroySamplerYcbcrConversion@ is an alias
--           of @vkDestroySamplerYcbcrConversionUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkDestroySamplerYcbcrConversionSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkDestroySamplerYcbcrConversion"
               vkDestroySamplerYcbcrConversionUnsafe ::
               VkDevice -- ^ device
                        ->
                 VkSamplerYcbcrConversion -- ^ ycbcrConversion
                                          -> Ptr VkAllocationCallbacks -- ^ pAllocator
                                                                       -> IO ()

#else
vkDestroySamplerYcbcrConversionUnsafe ::
                                      VkDevice -- ^ device
                                               ->
                                        VkSamplerYcbcrConversion -- ^ ycbcrConversion
                                                                 ->
                                          Ptr VkAllocationCallbacks -- ^ pAllocator
                                                                    -> IO ()
vkDestroySamplerYcbcrConversionUnsafe :: VkDevice
-> VkSamplerYcbcrConversion -> Ptr VkAllocationCallbacks -> IO ()
vkDestroySamplerYcbcrConversionUnsafe
  = IO
  (VkDevice
   -> VkSamplerYcbcrConversion -> Ptr VkAllocationCallbacks -> IO ())
-> VkDevice
-> VkSamplerYcbcrConversion
-> Ptr VkAllocationCallbacks
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkDestroySamplerYcbcrConversion)

{-# NOINLINE vkDestroySamplerYcbcrConversionUnsafe #-}
#endif

-- |
-- > void vkDestroySamplerYcbcrConversion
-- >     ( VkDevice device
-- >     , VkSamplerYcbcrConversion ycbcrConversion
-- >     , const VkAllocationCallbacks* pAllocator
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myDestroySamplerYcbcrConversion <- vkGetDeviceProc @VkDestroySamplerYcbcrConversion vkDevice
--
-- or less efficient:
--
-- > myDestroySamplerYcbcrConversion <- vkGetProc @VkDestroySamplerYcbcrConversion
--
-- __Note:__ @vkDestroySamplerYcbcrConversionUnsafe@ and @vkDestroySamplerYcbcrConversionSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkDestroySamplerYcbcrConversion@ is an alias
--           of @vkDestroySamplerYcbcrConversionUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkDestroySamplerYcbcrConversionSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkDestroySamplerYcbcrConversion"
               vkDestroySamplerYcbcrConversionSafe ::
               VkDevice -- ^ device
                        ->
                 VkSamplerYcbcrConversion -- ^ ycbcrConversion
                                          -> Ptr VkAllocationCallbacks -- ^ pAllocator
                                                                       -> IO ()

#else
vkDestroySamplerYcbcrConversionSafe ::
                                    VkDevice -- ^ device
                                             ->
                                      VkSamplerYcbcrConversion -- ^ ycbcrConversion
                                                               -> Ptr VkAllocationCallbacks -- ^ pAllocator
                                                                                            -> IO ()
vkDestroySamplerYcbcrConversionSafe :: VkDevice
-> VkSamplerYcbcrConversion -> Ptr VkAllocationCallbacks -> IO ()
vkDestroySamplerYcbcrConversionSafe
  = IO
  (VkDevice
   -> VkSamplerYcbcrConversion -> Ptr VkAllocationCallbacks -> IO ())
-> VkDevice
-> VkSamplerYcbcrConversion
-> Ptr VkAllocationCallbacks
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkDestroySamplerYcbcrConversion)

{-# NOINLINE vkDestroySamplerYcbcrConversionSafe #-}
#endif

-- |
-- > void vkDestroySamplerYcbcrConversion
-- >     ( VkDevice device
-- >     , VkSamplerYcbcrConversion ycbcrConversion
-- >     , const VkAllocationCallbacks* pAllocator
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myDestroySamplerYcbcrConversion <- vkGetDeviceProc @VkDestroySamplerYcbcrConversion vkDevice
--
-- or less efficient:
--
-- > myDestroySamplerYcbcrConversion <- vkGetProc @VkDestroySamplerYcbcrConversion
--
-- __Note:__ @vkDestroySamplerYcbcrConversionUnsafe@ and @vkDestroySamplerYcbcrConversionSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkDestroySamplerYcbcrConversion@ is an alias
--           of @vkDestroySamplerYcbcrConversionUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkDestroySamplerYcbcrConversionSafe@.
--
vkDestroySamplerYcbcrConversion ::
                                VkDevice -- ^ device
                                         ->
                                  VkSamplerYcbcrConversion -- ^ ycbcrConversion
                                                           -> Ptr VkAllocationCallbacks -- ^ pAllocator
                                                                                        -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkDestroySamplerYcbcrConversion
  = vkDestroySamplerYcbcrConversionUnsafe
#else
vkDestroySamplerYcbcrConversion :: VkDevice
-> VkSamplerYcbcrConversion -> Ptr VkAllocationCallbacks -> IO ()
vkDestroySamplerYcbcrConversion
  = VkDevice
-> VkSamplerYcbcrConversion -> Ptr VkAllocationCallbacks -> IO ()
vkDestroySamplerYcbcrConversionSafe

#endif
{-# INLINE vkDestroySamplerYcbcrConversion #-}

-- | > void vkDestroySamplerYcbcrConversion
--   >     ( VkDevice device
--   >     , VkSamplerYcbcrConversion ycbcrConversion
--   >     , const VkAllocationCallbacks* pAllocator
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion registry at www.khronos.org>
type HS_vkDestroySamplerYcbcrConversion =
     VkDevice -- ^ device
              ->
       VkSamplerYcbcrConversion -- ^ ycbcrConversion
                                -> Ptr VkAllocationCallbacks -- ^ pAllocator
                                                             -> IO ()

type PFN_vkDestroySamplerYcbcrConversion =
     FunPtr HS_vkDestroySamplerYcbcrConversion

foreign import ccall unsafe "dynamic"
               unwrapVkDestroySamplerYcbcrConversionUnsafe ::
               PFN_vkDestroySamplerYcbcrConversion ->
                 HS_vkDestroySamplerYcbcrConversion

foreign import ccall safe "dynamic"
               unwrapVkDestroySamplerYcbcrConversionSafe ::
               PFN_vkDestroySamplerYcbcrConversion ->
                 HS_vkDestroySamplerYcbcrConversion

instance VulkanProc "vkDestroySamplerYcbcrConversion" where
    type VkProcType "vkDestroySamplerYcbcrConversion" =
         HS_vkDestroySamplerYcbcrConversion
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkDestroySamplerYcbcrConversion

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkDestroySamplerYcbcrConversion)
-> VkProcType VkDestroySamplerYcbcrConversion
unwrapVkProcPtrUnsafe = FunPtr (VkProcType VkDestroySamplerYcbcrConversion)
-> VkProcType VkDestroySamplerYcbcrConversion
PFN_vkDestroySamplerYcbcrConversion
-> VkDevice
-> VkSamplerYcbcrConversion
-> Ptr VkAllocationCallbacks
-> IO ()
unwrapVkDestroySamplerYcbcrConversionUnsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkDestroySamplerYcbcrConversion)
-> VkProcType VkDestroySamplerYcbcrConversion
unwrapVkProcPtrSafe = FunPtr (VkProcType VkDestroySamplerYcbcrConversion)
-> VkProcType VkDestroySamplerYcbcrConversion
PFN_vkDestroySamplerYcbcrConversion
-> VkDevice
-> VkSamplerYcbcrConversion
-> Ptr VkAllocationCallbacks
-> IO ()
unwrapVkDestroySamplerYcbcrConversionSafe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO =
        VkStructureType 1000156000

pattern VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO =
        VkStructureType 1000156001

pattern VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO =
        VkStructureType 1000156002

pattern VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO =
        VkStructureType 1000156003

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES
        :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES
        = VkStructureType 1000156004

pattern VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES
        :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES :: VkStructureType
$mVK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES
        = VkStructureType 1000156005

pattern VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION :: VkObjectType

pattern $bVK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION :: VkObjectType
$mVK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION :: forall {r}. VkObjectType -> (Void# -> r) -> (Void# -> r) -> r
VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION =
        VkObjectType 1000156000

pattern VK_FORMAT_G8B8G8R8_422_UNORM :: VkFormat

pattern $bVK_FORMAT_G8B8G8R8_422_UNORM :: VkFormat
$mVK_FORMAT_G8B8G8R8_422_UNORM :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G8B8G8R8_422_UNORM = VkFormat 1000156000

pattern VK_FORMAT_B8G8R8G8_422_UNORM :: VkFormat

pattern $bVK_FORMAT_B8G8R8G8_422_UNORM :: VkFormat
$mVK_FORMAT_B8G8R8G8_422_UNORM :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_B8G8R8G8_422_UNORM = VkFormat 1000156001

pattern VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM :: VkFormat

pattern $bVK_FORMAT_G8_B8_R8_3PLANE_420_UNORM :: VkFormat
$mVK_FORMAT_G8_B8_R8_3PLANE_420_UNORM :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = VkFormat 1000156002

pattern VK_FORMAT_G8_B8R8_2PLANE_420_UNORM :: VkFormat

pattern $bVK_FORMAT_G8_B8R8_2PLANE_420_UNORM :: VkFormat
$mVK_FORMAT_G8_B8R8_2PLANE_420_UNORM :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = VkFormat 1000156003

pattern VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM :: VkFormat

pattern $bVK_FORMAT_G8_B8_R8_3PLANE_422_UNORM :: VkFormat
$mVK_FORMAT_G8_B8_R8_3PLANE_422_UNORM :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = VkFormat 1000156004

pattern VK_FORMAT_G8_B8R8_2PLANE_422_UNORM :: VkFormat

pattern $bVK_FORMAT_G8_B8R8_2PLANE_422_UNORM :: VkFormat
$mVK_FORMAT_G8_B8R8_2PLANE_422_UNORM :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = VkFormat 1000156005

pattern VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM :: VkFormat

pattern $bVK_FORMAT_G8_B8_R8_3PLANE_444_UNORM :: VkFormat
$mVK_FORMAT_G8_B8_R8_3PLANE_444_UNORM :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = VkFormat 1000156006

pattern VK_FORMAT_R10X6_UNORM_PACK16 :: VkFormat

pattern $bVK_FORMAT_R10X6_UNORM_PACK16 :: VkFormat
$mVK_FORMAT_R10X6_UNORM_PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_R10X6_UNORM_PACK16 = VkFormat 1000156007

pattern VK_FORMAT_R10X6G10X6_UNORM_2PACK16 :: VkFormat

pattern $bVK_FORMAT_R10X6G10X6_UNORM_2PACK16 :: VkFormat
$mVK_FORMAT_R10X6G10X6_UNORM_2PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = VkFormat 1000156008

pattern VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 :: VkFormat

pattern $bVK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 :: VkFormat
$mVK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 =
        VkFormat 1000156009

pattern VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 ::
        VkFormat

pattern $bVK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 :: VkFormat
$mVK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 =
        VkFormat 1000156010

pattern VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 ::
        VkFormat

pattern $bVK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 :: VkFormat
$mVK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 =
        VkFormat 1000156011

pattern VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 ::
        VkFormat

pattern $bVK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 :: VkFormat
$mVK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 =
        VkFormat 1000156012

pattern VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 ::
        VkFormat

pattern $bVK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 :: VkFormat
$mVK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 =
        VkFormat 1000156013

pattern VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 ::
        VkFormat

pattern $bVK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 :: VkFormat
$mVK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 =
        VkFormat 1000156014

pattern VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 ::
        VkFormat

pattern $bVK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 :: VkFormat
$mVK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 =
        VkFormat 1000156015

pattern VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 ::
        VkFormat

pattern $bVK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 :: VkFormat
$mVK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 =
        VkFormat 1000156016

pattern VK_FORMAT_R12X4_UNORM_PACK16 :: VkFormat

pattern $bVK_FORMAT_R12X4_UNORM_PACK16 :: VkFormat
$mVK_FORMAT_R12X4_UNORM_PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_R12X4_UNORM_PACK16 = VkFormat 1000156017

pattern VK_FORMAT_R12X4G12X4_UNORM_2PACK16 :: VkFormat

pattern $bVK_FORMAT_R12X4G12X4_UNORM_2PACK16 :: VkFormat
$mVK_FORMAT_R12X4G12X4_UNORM_2PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = VkFormat 1000156018

pattern VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 :: VkFormat

pattern $bVK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 :: VkFormat
$mVK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 =
        VkFormat 1000156019

pattern VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 ::
        VkFormat

pattern $bVK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 :: VkFormat
$mVK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 =
        VkFormat 1000156020

pattern VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 ::
        VkFormat

pattern $bVK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 :: VkFormat
$mVK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 =
        VkFormat 1000156021

pattern VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 ::
        VkFormat

pattern $bVK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 :: VkFormat
$mVK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 =
        VkFormat 1000156022

pattern VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 ::
        VkFormat

pattern $bVK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 :: VkFormat
$mVK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 =
        VkFormat 1000156023

pattern VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 ::
        VkFormat

pattern $bVK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 :: VkFormat
$mVK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 =
        VkFormat 1000156024

pattern VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 ::
        VkFormat

pattern $bVK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 :: VkFormat
$mVK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 =
        VkFormat 1000156025

pattern VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 ::
        VkFormat

pattern $bVK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 :: VkFormat
$mVK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 =
        VkFormat 1000156026

pattern VK_FORMAT_G16B16G16R16_422_UNORM :: VkFormat

pattern $bVK_FORMAT_G16B16G16R16_422_UNORM :: VkFormat
$mVK_FORMAT_G16B16G16R16_422_UNORM :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G16B16G16R16_422_UNORM = VkFormat 1000156027

pattern VK_FORMAT_B16G16R16G16_422_UNORM :: VkFormat

pattern $bVK_FORMAT_B16G16R16G16_422_UNORM :: VkFormat
$mVK_FORMAT_B16G16R16G16_422_UNORM :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_B16G16R16G16_422_UNORM = VkFormat 1000156028

pattern VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM :: VkFormat

pattern $bVK_FORMAT_G16_B16_R16_3PLANE_420_UNORM :: VkFormat
$mVK_FORMAT_G16_B16_R16_3PLANE_420_UNORM :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM =
        VkFormat 1000156029

pattern VK_FORMAT_G16_B16R16_2PLANE_420_UNORM :: VkFormat

pattern $bVK_FORMAT_G16_B16R16_2PLANE_420_UNORM :: VkFormat
$mVK_FORMAT_G16_B16R16_2PLANE_420_UNORM :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = VkFormat 1000156030

pattern VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM :: VkFormat

pattern $bVK_FORMAT_G16_B16_R16_3PLANE_422_UNORM :: VkFormat
$mVK_FORMAT_G16_B16_R16_3PLANE_422_UNORM :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM =
        VkFormat 1000156031

pattern VK_FORMAT_G16_B16R16_2PLANE_422_UNORM :: VkFormat

pattern $bVK_FORMAT_G16_B16R16_2PLANE_422_UNORM :: VkFormat
$mVK_FORMAT_G16_B16R16_2PLANE_422_UNORM :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = VkFormat 1000156032

pattern VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM :: VkFormat

pattern $bVK_FORMAT_G16_B16_R16_3PLANE_444_UNORM :: VkFormat
$mVK_FORMAT_G16_B16_R16_3PLANE_444_UNORM :: forall {r}. VkFormat -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM =
        VkFormat 1000156033

-- | bitpos = @4@
pattern VK_IMAGE_ASPECT_PLANE_0_BIT :: VkImageAspectBitmask a

pattern $bVK_IMAGE_ASPECT_PLANE_0_BIT :: forall (a :: FlagType). VkImageAspectBitmask a
$mVK_IMAGE_ASPECT_PLANE_0_BIT :: forall {r} {a :: FlagType}.
VkImageAspectBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_IMAGE_ASPECT_PLANE_0_BIT = VkImageAspectBitmask 16

-- | bitpos = @5@
pattern VK_IMAGE_ASPECT_PLANE_1_BIT :: VkImageAspectBitmask a

pattern $bVK_IMAGE_ASPECT_PLANE_1_BIT :: forall (a :: FlagType). VkImageAspectBitmask a
$mVK_IMAGE_ASPECT_PLANE_1_BIT :: forall {r} {a :: FlagType}.
VkImageAspectBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_IMAGE_ASPECT_PLANE_1_BIT = VkImageAspectBitmask 32

-- | bitpos = @6@
pattern VK_IMAGE_ASPECT_PLANE_2_BIT :: VkImageAspectBitmask a

pattern $bVK_IMAGE_ASPECT_PLANE_2_BIT :: forall (a :: FlagType). VkImageAspectBitmask a
$mVK_IMAGE_ASPECT_PLANE_2_BIT :: forall {r} {a :: FlagType}.
VkImageAspectBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_IMAGE_ASPECT_PLANE_2_BIT = VkImageAspectBitmask 64

-- | bitpos = @9@
pattern VK_IMAGE_CREATE_DISJOINT_BIT :: VkImageCreateBitmask a

pattern $bVK_IMAGE_CREATE_DISJOINT_BIT :: forall (a :: FlagType). VkImageCreateBitmask a
$mVK_IMAGE_CREATE_DISJOINT_BIT :: forall {r} {a :: FlagType}.
VkImageCreateBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_IMAGE_CREATE_DISJOINT_BIT = VkImageCreateBitmask 512

-- | Format can have midpoint rather than cosited chroma samples
--
--   bitpos = @17@
pattern VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT ::
        VkFormatFeatureBitmask a

pattern $bVK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT :: forall (a :: FlagType). VkFormatFeatureBitmask a
$mVK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT :: forall {r} {a :: FlagType}.
VkFormatFeatureBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT =
        VkFormatFeatureBitmask 131072

-- | Format can be used with linear filtering whilst color conversion is enabled
--
--   bitpos = @18@
pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT
        :: VkFormatFeatureBitmask a

pattern $bVK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT :: forall (a :: FlagType). VkFormatFeatureBitmask a
$mVK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT :: forall {r} {a :: FlagType}.
VkFormatFeatureBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT
        = VkFormatFeatureBitmask 262144

-- | Format can have different chroma, min and mag filters
--
--   bitpos = @19@
pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT
        :: VkFormatFeatureBitmask a

pattern $bVK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT :: forall (a :: FlagType). VkFormatFeatureBitmask a
$mVK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT :: forall {r} {a :: FlagType}.
VkFormatFeatureBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT
        = VkFormatFeatureBitmask 524288

-- | bitpos = @20@
pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT
        :: VkFormatFeatureBitmask a

pattern $bVK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT :: forall (a :: FlagType). VkFormatFeatureBitmask a
$mVK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT :: forall {r} {a :: FlagType}.
VkFormatFeatureBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT
        = VkFormatFeatureBitmask 1048576

-- | bitpos = @21@
pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT
        :: VkFormatFeatureBitmask a

pattern $bVK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT :: forall (a :: FlagType). VkFormatFeatureBitmask a
$mVK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT :: forall {r} {a :: FlagType}.
VkFormatFeatureBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT
        = VkFormatFeatureBitmask 2097152

-- | Format supports disjoint planes
--
--   bitpos = @22@
pattern VK_FORMAT_FEATURE_DISJOINT_BIT :: VkFormatFeatureBitmask a

pattern $bVK_FORMAT_FEATURE_DISJOINT_BIT :: forall (a :: FlagType). VkFormatFeatureBitmask a
$mVK_FORMAT_FEATURE_DISJOINT_BIT :: forall {r} {a :: FlagType}.
VkFormatFeatureBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_FEATURE_DISJOINT_BIT =
        VkFormatFeatureBitmask 4194304

-- | Format can have cosited rather than midpoint chroma samples
--
--   bitpos = @23@
pattern VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT ::
        VkFormatFeatureBitmask a

pattern $bVK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT :: forall (a :: FlagType). VkFormatFeatureBitmask a
$mVK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT :: forall {r} {a :: FlagType}.
VkFormatFeatureBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT =
        VkFormatFeatureBitmask 8388608

pattern VkCreateDescriptorUpdateTemplate :: CString

pattern $bVkCreateDescriptorUpdateTemplate :: CString
$mVkCreateDescriptorUpdateTemplate :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkCreateDescriptorUpdateTemplate <-
        (is_VkCreateDescriptorUpdateTemplate -> True)
  where
    VkCreateDescriptorUpdateTemplate
      = CString
_VkCreateDescriptorUpdateTemplate

{-# INLINE _VkCreateDescriptorUpdateTemplate #-}

_VkCreateDescriptorUpdateTemplate :: CString
_VkCreateDescriptorUpdateTemplate :: CString
_VkCreateDescriptorUpdateTemplate
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkCreateDescriptorUpdateTemplate\NUL"#

{-# INLINE is_VkCreateDescriptorUpdateTemplate #-}

is_VkCreateDescriptorUpdateTemplate :: CString -> Bool
is_VkCreateDescriptorUpdateTemplate :: CString -> Bool
is_VkCreateDescriptorUpdateTemplate
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkCreateDescriptorUpdateTemplate

type VkCreateDescriptorUpdateTemplate =
     "vkCreateDescriptorUpdateTemplate"

-- |
-- Success codes: 'VK_SUCCESS'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'.
--
-- > VkResult vkCreateDescriptorUpdateTemplate
-- >     ( VkDevice device
-- >     , const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo
-- >     , const VkAllocationCallbacks* pAllocator
-- >     , VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myCreateDescriptorUpdateTemplate <- vkGetDeviceProc @VkCreateDescriptorUpdateTemplate vkDevice
--
-- or less efficient:
--
-- > myCreateDescriptorUpdateTemplate <- vkGetProc @VkCreateDescriptorUpdateTemplate
--
-- __Note:__ @vkCreateDescriptorUpdateTemplateUnsafe@ and @vkCreateDescriptorUpdateTemplateSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkCreateDescriptorUpdateTemplate@ is an alias
--           of @vkCreateDescriptorUpdateTemplateUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkCreateDescriptorUpdateTemplateSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkCreateDescriptorUpdateTemplate"
               vkCreateDescriptorUpdateTemplateUnsafe ::
               VkDevice -- ^ device
                        ->
                 Ptr VkDescriptorUpdateTemplateCreateInfo -- ^ pCreateInfo
                                                          ->
                   Ptr VkAllocationCallbacks -- ^ pAllocator
                                             ->
                     Ptr VkDescriptorUpdateTemplate -- ^ pDescriptorUpdateTemplate
                                                    -> IO VkResult

#else
vkCreateDescriptorUpdateTemplateUnsafe ::
                                       VkDevice -- ^ device
                                                ->
                                         Ptr VkDescriptorUpdateTemplateCreateInfo -- ^ pCreateInfo
                                                                                  ->
                                           Ptr VkAllocationCallbacks -- ^ pAllocator
                                                                     ->
                                             Ptr VkDescriptorUpdateTemplate -- ^ pDescriptorUpdateTemplate
                                                                            -> IO VkResult
vkCreateDescriptorUpdateTemplateUnsafe :: VkDevice
-> Ptr VkDescriptorUpdateTemplateCreateInfo
-> Ptr VkAllocationCallbacks
-> Ptr VkDescriptorUpdateTemplate
-> IO VkResult
vkCreateDescriptorUpdateTemplateUnsafe
  = IO
  (VkDevice
   -> Ptr VkDescriptorUpdateTemplateCreateInfo
   -> Ptr VkAllocationCallbacks
   -> Ptr VkDescriptorUpdateTemplate
   -> IO VkResult)
-> VkDevice
-> Ptr VkDescriptorUpdateTemplateCreateInfo
-> Ptr VkAllocationCallbacks
-> Ptr VkDescriptorUpdateTemplate
-> IO VkResult
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkCreateDescriptorUpdateTemplate)

{-# NOINLINE vkCreateDescriptorUpdateTemplateUnsafe #-}
#endif

-- |
-- Success codes: 'VK_SUCCESS'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'.
--
-- > VkResult vkCreateDescriptorUpdateTemplate
-- >     ( VkDevice device
-- >     , const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo
-- >     , const VkAllocationCallbacks* pAllocator
-- >     , VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myCreateDescriptorUpdateTemplate <- vkGetDeviceProc @VkCreateDescriptorUpdateTemplate vkDevice
--
-- or less efficient:
--
-- > myCreateDescriptorUpdateTemplate <- vkGetProc @VkCreateDescriptorUpdateTemplate
--
-- __Note:__ @vkCreateDescriptorUpdateTemplateUnsafe@ and @vkCreateDescriptorUpdateTemplateSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkCreateDescriptorUpdateTemplate@ is an alias
--           of @vkCreateDescriptorUpdateTemplateUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkCreateDescriptorUpdateTemplateSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkCreateDescriptorUpdateTemplate"
               vkCreateDescriptorUpdateTemplateSafe ::
               VkDevice -- ^ device
                        ->
                 Ptr VkDescriptorUpdateTemplateCreateInfo -- ^ pCreateInfo
                                                          ->
                   Ptr VkAllocationCallbacks -- ^ pAllocator
                                             ->
                     Ptr VkDescriptorUpdateTemplate -- ^ pDescriptorUpdateTemplate
                                                    -> IO VkResult

#else
vkCreateDescriptorUpdateTemplateSafe ::
                                     VkDevice -- ^ device
                                              ->
                                       Ptr VkDescriptorUpdateTemplateCreateInfo -- ^ pCreateInfo
                                                                                ->
                                         Ptr VkAllocationCallbacks -- ^ pAllocator
                                                                   ->
                                           Ptr VkDescriptorUpdateTemplate -- ^ pDescriptorUpdateTemplate
                                                                          -> IO VkResult
vkCreateDescriptorUpdateTemplateSafe :: VkDevice
-> Ptr VkDescriptorUpdateTemplateCreateInfo
-> Ptr VkAllocationCallbacks
-> Ptr VkDescriptorUpdateTemplate
-> IO VkResult
vkCreateDescriptorUpdateTemplateSafe
  = IO
  (VkDevice
   -> Ptr VkDescriptorUpdateTemplateCreateInfo
   -> Ptr VkAllocationCallbacks
   -> Ptr VkDescriptorUpdateTemplate
   -> IO VkResult)
-> VkDevice
-> Ptr VkDescriptorUpdateTemplateCreateInfo
-> Ptr VkAllocationCallbacks
-> Ptr VkDescriptorUpdateTemplate
-> IO VkResult
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkCreateDescriptorUpdateTemplate)

{-# NOINLINE vkCreateDescriptorUpdateTemplateSafe #-}
#endif

-- |
-- Success codes: 'VK_SUCCESS'.
--
-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'.
--
-- > VkResult vkCreateDescriptorUpdateTemplate
-- >     ( VkDevice device
-- >     , const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo
-- >     , const VkAllocationCallbacks* pAllocator
-- >     , VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myCreateDescriptorUpdateTemplate <- vkGetDeviceProc @VkCreateDescriptorUpdateTemplate vkDevice
--
-- or less efficient:
--
-- > myCreateDescriptorUpdateTemplate <- vkGetProc @VkCreateDescriptorUpdateTemplate
--
-- __Note:__ @vkCreateDescriptorUpdateTemplateUnsafe@ and @vkCreateDescriptorUpdateTemplateSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkCreateDescriptorUpdateTemplate@ is an alias
--           of @vkCreateDescriptorUpdateTemplateUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkCreateDescriptorUpdateTemplateSafe@.
--
vkCreateDescriptorUpdateTemplate ::
                                 VkDevice -- ^ device
                                          ->
                                   Ptr VkDescriptorUpdateTemplateCreateInfo -- ^ pCreateInfo
                                                                            ->
                                     Ptr VkAllocationCallbacks -- ^ pAllocator
                                                               ->
                                       Ptr VkDescriptorUpdateTemplate -- ^ pDescriptorUpdateTemplate
                                                                      -> IO VkResult
#ifdef UNSAFE_FFI_DEFAULT
vkCreateDescriptorUpdateTemplate
  = vkCreateDescriptorUpdateTemplateUnsafe
#else
vkCreateDescriptorUpdateTemplate :: VkDevice
-> Ptr VkDescriptorUpdateTemplateCreateInfo
-> Ptr VkAllocationCallbacks
-> Ptr VkDescriptorUpdateTemplate
-> IO VkResult
vkCreateDescriptorUpdateTemplate
  = VkDevice
-> Ptr VkDescriptorUpdateTemplateCreateInfo
-> Ptr VkAllocationCallbacks
-> Ptr VkDescriptorUpdateTemplate
-> IO VkResult
vkCreateDescriptorUpdateTemplateSafe

#endif
{-# INLINE vkCreateDescriptorUpdateTemplate #-}

-- | Success codes: 'VK_SUCCESS'.
--
--   Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'.
--
--   > VkResult vkCreateDescriptorUpdateTemplate
--   >     ( VkDevice device
--   >     , const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo
--   >     , const VkAllocationCallbacks* pAllocator
--   >     , VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate registry at www.khronos.org>
type HS_vkCreateDescriptorUpdateTemplate =
     VkDevice -- ^ device
              ->
       Ptr VkDescriptorUpdateTemplateCreateInfo -- ^ pCreateInfo
                                                ->
         Ptr VkAllocationCallbacks -- ^ pAllocator
                                   ->
           Ptr VkDescriptorUpdateTemplate -- ^ pDescriptorUpdateTemplate
                                          -> IO VkResult

type PFN_vkCreateDescriptorUpdateTemplate =
     FunPtr HS_vkCreateDescriptorUpdateTemplate

foreign import ccall unsafe "dynamic"
               unwrapVkCreateDescriptorUpdateTemplateUnsafe ::
               PFN_vkCreateDescriptorUpdateTemplate ->
                 HS_vkCreateDescriptorUpdateTemplate

foreign import ccall safe "dynamic"
               unwrapVkCreateDescriptorUpdateTemplateSafe ::
               PFN_vkCreateDescriptorUpdateTemplate ->
                 HS_vkCreateDescriptorUpdateTemplate

instance VulkanProc "vkCreateDescriptorUpdateTemplate" where
    type VkProcType "vkCreateDescriptorUpdateTemplate" =
         HS_vkCreateDescriptorUpdateTemplate
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkCreateDescriptorUpdateTemplate

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkCreateDescriptorUpdateTemplate)
-> VkProcType VkCreateDescriptorUpdateTemplate
unwrapVkProcPtrUnsafe
      = FunPtr (VkProcType VkCreateDescriptorUpdateTemplate)
-> VkProcType VkCreateDescriptorUpdateTemplate
PFN_vkCreateDescriptorUpdateTemplate
-> VkDevice
-> Ptr VkDescriptorUpdateTemplateCreateInfo
-> Ptr VkAllocationCallbacks
-> Ptr VkDescriptorUpdateTemplate
-> IO VkResult
unwrapVkCreateDescriptorUpdateTemplateUnsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkCreateDescriptorUpdateTemplate)
-> VkProcType VkCreateDescriptorUpdateTemplate
unwrapVkProcPtrSafe = FunPtr (VkProcType VkCreateDescriptorUpdateTemplate)
-> VkProcType VkCreateDescriptorUpdateTemplate
PFN_vkCreateDescriptorUpdateTemplate
-> VkDevice
-> Ptr VkDescriptorUpdateTemplateCreateInfo
-> Ptr VkAllocationCallbacks
-> Ptr VkDescriptorUpdateTemplate
-> IO VkResult
unwrapVkCreateDescriptorUpdateTemplateSafe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VkDestroyDescriptorUpdateTemplate :: CString

pattern $bVkDestroyDescriptorUpdateTemplate :: CString
$mVkDestroyDescriptorUpdateTemplate :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkDestroyDescriptorUpdateTemplate <-
        (is_VkDestroyDescriptorUpdateTemplate -> True)
  where
    VkDestroyDescriptorUpdateTemplate
      = CString
_VkDestroyDescriptorUpdateTemplate

{-# INLINE _VkDestroyDescriptorUpdateTemplate #-}

_VkDestroyDescriptorUpdateTemplate :: CString
_VkDestroyDescriptorUpdateTemplate :: CString
_VkDestroyDescriptorUpdateTemplate
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkDestroyDescriptorUpdateTemplate\NUL"#

{-# INLINE is_VkDestroyDescriptorUpdateTemplate #-}

is_VkDestroyDescriptorUpdateTemplate :: CString -> Bool
is_VkDestroyDescriptorUpdateTemplate :: CString -> Bool
is_VkDestroyDescriptorUpdateTemplate
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkDestroyDescriptorUpdateTemplate

type VkDestroyDescriptorUpdateTemplate =
     "vkDestroyDescriptorUpdateTemplate"

-- |
-- > void vkDestroyDescriptorUpdateTemplate
-- >     ( VkDevice device
-- >     , VkDescriptorUpdateTemplate descriptorUpdateTemplate
-- >     , const VkAllocationCallbacks* pAllocator
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myDestroyDescriptorUpdateTemplate <- vkGetDeviceProc @VkDestroyDescriptorUpdateTemplate vkDevice
--
-- or less efficient:
--
-- > myDestroyDescriptorUpdateTemplate <- vkGetProc @VkDestroyDescriptorUpdateTemplate
--
-- __Note:__ @vkDestroyDescriptorUpdateTemplateUnsafe@ and @vkDestroyDescriptorUpdateTemplateSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkDestroyDescriptorUpdateTemplate@ is an alias
--           of @vkDestroyDescriptorUpdateTemplateUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkDestroyDescriptorUpdateTemplateSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkDestroyDescriptorUpdateTemplate"
               vkDestroyDescriptorUpdateTemplateUnsafe ::
               VkDevice -- ^ device
                        ->
                 VkDescriptorUpdateTemplate -- ^ descriptorUpdateTemplate
                                            -> Ptr VkAllocationCallbacks -- ^ pAllocator
                                                                         -> IO ()

#else
vkDestroyDescriptorUpdateTemplateUnsafe ::
                                        VkDevice -- ^ device
                                                 ->
                                          VkDescriptorUpdateTemplate -- ^ descriptorUpdateTemplate
                                                                     ->
                                            Ptr VkAllocationCallbacks -- ^ pAllocator
                                                                      -> IO ()
vkDestroyDescriptorUpdateTemplateUnsafe :: VkDevice
-> VkDescriptorUpdateTemplate -> Ptr VkAllocationCallbacks -> IO ()
vkDestroyDescriptorUpdateTemplateUnsafe
  = IO
  (VkDevice
   -> VkDescriptorUpdateTemplate
   -> Ptr VkAllocationCallbacks
   -> IO ())
-> VkDevice
-> VkDescriptorUpdateTemplate
-> Ptr VkAllocationCallbacks
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkDestroyDescriptorUpdateTemplate)

{-# NOINLINE vkDestroyDescriptorUpdateTemplateUnsafe #-}
#endif

-- |
-- > void vkDestroyDescriptorUpdateTemplate
-- >     ( VkDevice device
-- >     , VkDescriptorUpdateTemplate descriptorUpdateTemplate
-- >     , const VkAllocationCallbacks* pAllocator
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myDestroyDescriptorUpdateTemplate <- vkGetDeviceProc @VkDestroyDescriptorUpdateTemplate vkDevice
--
-- or less efficient:
--
-- > myDestroyDescriptorUpdateTemplate <- vkGetProc @VkDestroyDescriptorUpdateTemplate
--
-- __Note:__ @vkDestroyDescriptorUpdateTemplateUnsafe@ and @vkDestroyDescriptorUpdateTemplateSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkDestroyDescriptorUpdateTemplate@ is an alias
--           of @vkDestroyDescriptorUpdateTemplateUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkDestroyDescriptorUpdateTemplateSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkDestroyDescriptorUpdateTemplate"
               vkDestroyDescriptorUpdateTemplateSafe ::
               VkDevice -- ^ device
                        ->
                 VkDescriptorUpdateTemplate -- ^ descriptorUpdateTemplate
                                            -> Ptr VkAllocationCallbacks -- ^ pAllocator
                                                                         -> IO ()

#else
vkDestroyDescriptorUpdateTemplateSafe ::
                                      VkDevice -- ^ device
                                               ->
                                        VkDescriptorUpdateTemplate -- ^ descriptorUpdateTemplate
                                                                   ->
                                          Ptr VkAllocationCallbacks -- ^ pAllocator
                                                                    -> IO ()
vkDestroyDescriptorUpdateTemplateSafe :: VkDevice
-> VkDescriptorUpdateTemplate -> Ptr VkAllocationCallbacks -> IO ()
vkDestroyDescriptorUpdateTemplateSafe
  = IO
  (VkDevice
   -> VkDescriptorUpdateTemplate
   -> Ptr VkAllocationCallbacks
   -> IO ())
-> VkDevice
-> VkDescriptorUpdateTemplate
-> Ptr VkAllocationCallbacks
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkDestroyDescriptorUpdateTemplate)

{-# NOINLINE vkDestroyDescriptorUpdateTemplateSafe #-}
#endif

-- |
-- > void vkDestroyDescriptorUpdateTemplate
-- >     ( VkDevice device
-- >     , VkDescriptorUpdateTemplate descriptorUpdateTemplate
-- >     , const VkAllocationCallbacks* pAllocator
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myDestroyDescriptorUpdateTemplate <- vkGetDeviceProc @VkDestroyDescriptorUpdateTemplate vkDevice
--
-- or less efficient:
--
-- > myDestroyDescriptorUpdateTemplate <- vkGetProc @VkDestroyDescriptorUpdateTemplate
--
-- __Note:__ @vkDestroyDescriptorUpdateTemplateUnsafe@ and @vkDestroyDescriptorUpdateTemplateSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkDestroyDescriptorUpdateTemplate@ is an alias
--           of @vkDestroyDescriptorUpdateTemplateUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkDestroyDescriptorUpdateTemplateSafe@.
--
vkDestroyDescriptorUpdateTemplate ::
                                  VkDevice -- ^ device
                                           ->
                                    VkDescriptorUpdateTemplate -- ^ descriptorUpdateTemplate
                                                               -> Ptr VkAllocationCallbacks -- ^ pAllocator
                                                                                            -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkDestroyDescriptorUpdateTemplate
  = vkDestroyDescriptorUpdateTemplateUnsafe
#else
vkDestroyDescriptorUpdateTemplate :: VkDevice
-> VkDescriptorUpdateTemplate -> Ptr VkAllocationCallbacks -> IO ()
vkDestroyDescriptorUpdateTemplate
  = VkDevice
-> VkDescriptorUpdateTemplate -> Ptr VkAllocationCallbacks -> IO ()
vkDestroyDescriptorUpdateTemplateSafe

#endif
{-# INLINE vkDestroyDescriptorUpdateTemplate #-}

-- | > void vkDestroyDescriptorUpdateTemplate
--   >     ( VkDevice device
--   >     , VkDescriptorUpdateTemplate descriptorUpdateTemplate
--   >     , const VkAllocationCallbacks* pAllocator
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate registry at www.khronos.org>
type HS_vkDestroyDescriptorUpdateTemplate =
     VkDevice -- ^ device
              ->
       VkDescriptorUpdateTemplate -- ^ descriptorUpdateTemplate
                                  -> Ptr VkAllocationCallbacks -- ^ pAllocator
                                                               -> IO ()

type PFN_vkDestroyDescriptorUpdateTemplate =
     FunPtr HS_vkDestroyDescriptorUpdateTemplate

foreign import ccall unsafe "dynamic"
               unwrapVkDestroyDescriptorUpdateTemplateUnsafe ::
               PFN_vkDestroyDescriptorUpdateTemplate ->
                 HS_vkDestroyDescriptorUpdateTemplate

foreign import ccall safe "dynamic"
               unwrapVkDestroyDescriptorUpdateTemplateSafe ::
               PFN_vkDestroyDescriptorUpdateTemplate ->
                 HS_vkDestroyDescriptorUpdateTemplate

instance VulkanProc "vkDestroyDescriptorUpdateTemplate" where
    type VkProcType "vkDestroyDescriptorUpdateTemplate" =
         HS_vkDestroyDescriptorUpdateTemplate
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkDestroyDescriptorUpdateTemplate

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkDestroyDescriptorUpdateTemplate)
-> VkProcType VkDestroyDescriptorUpdateTemplate
unwrapVkProcPtrUnsafe
      = FunPtr (VkProcType VkDestroyDescriptorUpdateTemplate)
-> VkProcType VkDestroyDescriptorUpdateTemplate
PFN_vkDestroyDescriptorUpdateTemplate
-> VkDevice
-> VkDescriptorUpdateTemplate
-> Ptr VkAllocationCallbacks
-> IO ()
unwrapVkDestroyDescriptorUpdateTemplateUnsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkDestroyDescriptorUpdateTemplate)
-> VkProcType VkDestroyDescriptorUpdateTemplate
unwrapVkProcPtrSafe = FunPtr (VkProcType VkDestroyDescriptorUpdateTemplate)
-> VkProcType VkDestroyDescriptorUpdateTemplate
PFN_vkDestroyDescriptorUpdateTemplate
-> VkDevice
-> VkDescriptorUpdateTemplate
-> Ptr VkAllocationCallbacks
-> IO ()
unwrapVkDestroyDescriptorUpdateTemplateSafe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VkUpdateDescriptorSetWithTemplate :: CString

pattern $bVkUpdateDescriptorSetWithTemplate :: CString
$mVkUpdateDescriptorSetWithTemplate :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkUpdateDescriptorSetWithTemplate <-
        (is_VkUpdateDescriptorSetWithTemplate -> True)
  where
    VkUpdateDescriptorSetWithTemplate
      = CString
_VkUpdateDescriptorSetWithTemplate

{-# INLINE _VkUpdateDescriptorSetWithTemplate #-}

_VkUpdateDescriptorSetWithTemplate :: CString
_VkUpdateDescriptorSetWithTemplate :: CString
_VkUpdateDescriptorSetWithTemplate
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkUpdateDescriptorSetWithTemplate\NUL"#

{-# INLINE is_VkUpdateDescriptorSetWithTemplate #-}

is_VkUpdateDescriptorSetWithTemplate :: CString -> Bool
is_VkUpdateDescriptorSetWithTemplate :: CString -> Bool
is_VkUpdateDescriptorSetWithTemplate
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkUpdateDescriptorSetWithTemplate

type VkUpdateDescriptorSetWithTemplate =
     "vkUpdateDescriptorSetWithTemplate"

-- |
-- > void vkUpdateDescriptorSetWithTemplate
-- >     ( VkDevice device
-- >     , VkDescriptorSet descriptorSet
-- >     , VkDescriptorUpdateTemplate descriptorUpdateTemplate
-- >     , const void* pData
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myUpdateDescriptorSetWithTemplate <- vkGetDeviceProc @VkUpdateDescriptorSetWithTemplate vkDevice
--
-- or less efficient:
--
-- > myUpdateDescriptorSetWithTemplate <- vkGetProc @VkUpdateDescriptorSetWithTemplate
--
-- __Note:__ @vkUpdateDescriptorSetWithTemplateUnsafe@ and @vkUpdateDescriptorSetWithTemplateSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkUpdateDescriptorSetWithTemplate@ is an alias
--           of @vkUpdateDescriptorSetWithTemplateUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkUpdateDescriptorSetWithTemplateSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkUpdateDescriptorSetWithTemplate"
               vkUpdateDescriptorSetWithTemplateUnsafe ::
               VkDevice -- ^ device
                        ->
                 VkDescriptorSet -- ^ descriptorSet
                                 -> VkDescriptorUpdateTemplate -- ^ descriptorUpdateTemplate
                                                               -> Ptr Void -- ^ pData
                                                                           -> IO ()

#else
vkUpdateDescriptorSetWithTemplateUnsafe ::
                                        VkDevice -- ^ device
                                                 ->
                                          VkDescriptorSet -- ^ descriptorSet
                                                          ->
                                            VkDescriptorUpdateTemplate -- ^ descriptorUpdateTemplate
                                                                       -> Ptr Void -- ^ pData
                                                                                   -> IO ()
vkUpdateDescriptorSetWithTemplateUnsafe :: VkDevice
-> VkDescriptorSet
-> VkDescriptorUpdateTemplate
-> Ptr Void
-> IO ()
vkUpdateDescriptorSetWithTemplateUnsafe
  = IO
  (VkDevice
   -> VkDescriptorSet
   -> VkDescriptorUpdateTemplate
   -> Ptr Void
   -> IO ())
-> VkDevice
-> VkDescriptorSet
-> VkDescriptorUpdateTemplate
-> Ptr Void
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkUpdateDescriptorSetWithTemplate)

{-# NOINLINE vkUpdateDescriptorSetWithTemplateUnsafe #-}
#endif

-- |
-- > void vkUpdateDescriptorSetWithTemplate
-- >     ( VkDevice device
-- >     , VkDescriptorSet descriptorSet
-- >     , VkDescriptorUpdateTemplate descriptorUpdateTemplate
-- >     , const void* pData
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myUpdateDescriptorSetWithTemplate <- vkGetDeviceProc @VkUpdateDescriptorSetWithTemplate vkDevice
--
-- or less efficient:
--
-- > myUpdateDescriptorSetWithTemplate <- vkGetProc @VkUpdateDescriptorSetWithTemplate
--
-- __Note:__ @vkUpdateDescriptorSetWithTemplateUnsafe@ and @vkUpdateDescriptorSetWithTemplateSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkUpdateDescriptorSetWithTemplate@ is an alias
--           of @vkUpdateDescriptorSetWithTemplateUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkUpdateDescriptorSetWithTemplateSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkUpdateDescriptorSetWithTemplate"
               vkUpdateDescriptorSetWithTemplateSafe ::
               VkDevice -- ^ device
                        ->
                 VkDescriptorSet -- ^ descriptorSet
                                 -> VkDescriptorUpdateTemplate -- ^ descriptorUpdateTemplate
                                                               -> Ptr Void -- ^ pData
                                                                           -> IO ()

#else
vkUpdateDescriptorSetWithTemplateSafe ::
                                      VkDevice -- ^ device
                                               ->
                                        VkDescriptorSet -- ^ descriptorSet
                                                        ->
                                          VkDescriptorUpdateTemplate -- ^ descriptorUpdateTemplate
                                                                     -> Ptr Void -- ^ pData
                                                                                 -> IO ()
vkUpdateDescriptorSetWithTemplateSafe :: VkDevice
-> VkDescriptorSet
-> VkDescriptorUpdateTemplate
-> Ptr Void
-> IO ()
vkUpdateDescriptorSetWithTemplateSafe
  = IO
  (VkDevice
   -> VkDescriptorSet
   -> VkDescriptorUpdateTemplate
   -> Ptr Void
   -> IO ())
-> VkDevice
-> VkDescriptorSet
-> VkDescriptorUpdateTemplate
-> Ptr Void
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkUpdateDescriptorSetWithTemplate)

{-# NOINLINE vkUpdateDescriptorSetWithTemplateSafe #-}
#endif

-- |
-- > void vkUpdateDescriptorSetWithTemplate
-- >     ( VkDevice device
-- >     , VkDescriptorSet descriptorSet
-- >     , VkDescriptorUpdateTemplate descriptorUpdateTemplate
-- >     , const void* pData
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myUpdateDescriptorSetWithTemplate <- vkGetDeviceProc @VkUpdateDescriptorSetWithTemplate vkDevice
--
-- or less efficient:
--
-- > myUpdateDescriptorSetWithTemplate <- vkGetProc @VkUpdateDescriptorSetWithTemplate
--
-- __Note:__ @vkUpdateDescriptorSetWithTemplateUnsafe@ and @vkUpdateDescriptorSetWithTemplateSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkUpdateDescriptorSetWithTemplate@ is an alias
--           of @vkUpdateDescriptorSetWithTemplateUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkUpdateDescriptorSetWithTemplateSafe@.
--
vkUpdateDescriptorSetWithTemplate ::
                                  VkDevice -- ^ device
                                           ->
                                    VkDescriptorSet -- ^ descriptorSet
                                                    ->
                                      VkDescriptorUpdateTemplate -- ^ descriptorUpdateTemplate
                                                                 -> Ptr Void -- ^ pData
                                                                             -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkUpdateDescriptorSetWithTemplate
  = vkUpdateDescriptorSetWithTemplateUnsafe
#else
vkUpdateDescriptorSetWithTemplate :: VkDevice
-> VkDescriptorSet
-> VkDescriptorUpdateTemplate
-> Ptr Void
-> IO ()
vkUpdateDescriptorSetWithTemplate
  = VkDevice
-> VkDescriptorSet
-> VkDescriptorUpdateTemplate
-> Ptr Void
-> IO ()
vkUpdateDescriptorSetWithTemplateSafe

#endif
{-# INLINE vkUpdateDescriptorSetWithTemplate #-}

-- | > void vkUpdateDescriptorSetWithTemplate
--   >     ( VkDevice device
--   >     , VkDescriptorSet descriptorSet
--   >     , VkDescriptorUpdateTemplate descriptorUpdateTemplate
--   >     , const void* pData
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate registry at www.khronos.org>
type HS_vkUpdateDescriptorSetWithTemplate =
     VkDevice -- ^ device
              ->
       VkDescriptorSet -- ^ descriptorSet
                       -> VkDescriptorUpdateTemplate -- ^ descriptorUpdateTemplate
                                                     -> Ptr Void -- ^ pData
                                                                 -> IO ()

type PFN_vkUpdateDescriptorSetWithTemplate =
     FunPtr HS_vkUpdateDescriptorSetWithTemplate

foreign import ccall unsafe "dynamic"
               unwrapVkUpdateDescriptorSetWithTemplateUnsafe ::
               PFN_vkUpdateDescriptorSetWithTemplate ->
                 HS_vkUpdateDescriptorSetWithTemplate

foreign import ccall safe "dynamic"
               unwrapVkUpdateDescriptorSetWithTemplateSafe ::
               PFN_vkUpdateDescriptorSetWithTemplate ->
                 HS_vkUpdateDescriptorSetWithTemplate

instance VulkanProc "vkUpdateDescriptorSetWithTemplate" where
    type VkProcType "vkUpdateDescriptorSetWithTemplate" =
         HS_vkUpdateDescriptorSetWithTemplate
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkUpdateDescriptorSetWithTemplate

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkUpdateDescriptorSetWithTemplate)
-> VkProcType VkUpdateDescriptorSetWithTemplate
unwrapVkProcPtrUnsafe
      = FunPtr (VkProcType VkUpdateDescriptorSetWithTemplate)
-> VkProcType VkUpdateDescriptorSetWithTemplate
PFN_vkUpdateDescriptorSetWithTemplate
-> VkDevice
-> VkDescriptorSet
-> VkDescriptorUpdateTemplate
-> Ptr Void
-> IO ()
unwrapVkUpdateDescriptorSetWithTemplateUnsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkUpdateDescriptorSetWithTemplate)
-> VkProcType VkUpdateDescriptorSetWithTemplate
unwrapVkProcPtrSafe = FunPtr (VkProcType VkUpdateDescriptorSetWithTemplate)
-> VkProcType VkUpdateDescriptorSetWithTemplate
PFN_vkUpdateDescriptorSetWithTemplate
-> VkDevice
-> VkDescriptorSet
-> VkDescriptorUpdateTemplate
-> Ptr Void
-> IO ()
unwrapVkUpdateDescriptorSetWithTemplateSafe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO =
        VkStructureType 1000085000

pattern VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE :: VkObjectType

pattern $bVK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE :: VkObjectType
$mVK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE :: forall {r}. VkObjectType -> (Void# -> r) -> (Void# -> r) -> r
VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE =
        VkObjectType 1000085000

pattern VkGetPhysicalDeviceExternalBufferProperties :: CString

pattern $bVkGetPhysicalDeviceExternalBufferProperties :: CString
$mVkGetPhysicalDeviceExternalBufferProperties :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkGetPhysicalDeviceExternalBufferProperties <-
        (is_VkGetPhysicalDeviceExternalBufferProperties -> True)
  where
    VkGetPhysicalDeviceExternalBufferProperties
      = CString
_VkGetPhysicalDeviceExternalBufferProperties

{-# INLINE _VkGetPhysicalDeviceExternalBufferProperties #-}

_VkGetPhysicalDeviceExternalBufferProperties :: CString
_VkGetPhysicalDeviceExternalBufferProperties :: CString
_VkGetPhysicalDeviceExternalBufferProperties
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkGetPhysicalDeviceExternalBufferProperties\NUL"#

{-# INLINE is_VkGetPhysicalDeviceExternalBufferProperties #-}

is_VkGetPhysicalDeviceExternalBufferProperties :: CString -> Bool
is_VkGetPhysicalDeviceExternalBufferProperties :: CString -> Bool
is_VkGetPhysicalDeviceExternalBufferProperties
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      CString -> CString -> Ordering
cmpCStrings CString
_VkGetPhysicalDeviceExternalBufferProperties

type VkGetPhysicalDeviceExternalBufferProperties =
     "vkGetPhysicalDeviceExternalBufferProperties"

-- |
-- > void vkGetPhysicalDeviceExternalBufferProperties
-- >     ( VkPhysicalDevice physicalDevice
-- >     , const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo
-- >     , VkExternalBufferProperties* pExternalBufferProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceExternalBufferProperties <- vkGetInstanceProc @VkGetPhysicalDeviceExternalBufferProperties vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceExternalBufferProperties <- vkGetProc @VkGetPhysicalDeviceExternalBufferProperties
--
-- __Note:__ @vkGetPhysicalDeviceExternalBufferPropertiesUnsafe@ and @vkGetPhysicalDeviceExternalBufferPropertiesSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceExternalBufferProperties@ is an alias
--           of @vkGetPhysicalDeviceExternalBufferPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceExternalBufferPropertiesSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe
               "vkGetPhysicalDeviceExternalBufferProperties"
               vkGetPhysicalDeviceExternalBufferPropertiesUnsafe ::
               VkPhysicalDevice -- ^ physicalDevice
                                ->
                 Ptr VkPhysicalDeviceExternalBufferInfo -- ^ pExternalBufferInfo
                                                        ->
                   Ptr VkExternalBufferProperties -- ^ pExternalBufferProperties
                                                  -> IO ()

#else
vkGetPhysicalDeviceExternalBufferPropertiesUnsafe ::
                                                  VkPhysicalDevice -- ^ physicalDevice
                                                                   ->
                                                    Ptr VkPhysicalDeviceExternalBufferInfo -- ^ pExternalBufferInfo
                                                                                           ->
                                                      Ptr VkExternalBufferProperties -- ^ pExternalBufferProperties
                                                                                     -> IO ()
vkGetPhysicalDeviceExternalBufferPropertiesUnsafe :: VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalBufferInfo
-> Ptr VkExternalBufferProperties
-> IO ()
vkGetPhysicalDeviceExternalBufferPropertiesUnsafe
  = IO
  (VkPhysicalDevice
   -> Ptr VkPhysicalDeviceExternalBufferInfo
   -> Ptr VkExternalBufferProperties
   -> IO ())
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalBufferInfo
-> Ptr VkExternalBufferProperties
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkGetPhysicalDeviceExternalBufferProperties)

{-# NOINLINE vkGetPhysicalDeviceExternalBufferPropertiesUnsafe #-}
#endif

-- |
-- > void vkGetPhysicalDeviceExternalBufferProperties
-- >     ( VkPhysicalDevice physicalDevice
-- >     , const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo
-- >     , VkExternalBufferProperties* pExternalBufferProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceExternalBufferProperties <- vkGetInstanceProc @VkGetPhysicalDeviceExternalBufferProperties vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceExternalBufferProperties <- vkGetProc @VkGetPhysicalDeviceExternalBufferProperties
--
-- __Note:__ @vkGetPhysicalDeviceExternalBufferPropertiesUnsafe@ and @vkGetPhysicalDeviceExternalBufferPropertiesSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceExternalBufferProperties@ is an alias
--           of @vkGetPhysicalDeviceExternalBufferPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceExternalBufferPropertiesSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe
               "vkGetPhysicalDeviceExternalBufferProperties"
               vkGetPhysicalDeviceExternalBufferPropertiesSafe ::
               VkPhysicalDevice -- ^ physicalDevice
                                ->
                 Ptr VkPhysicalDeviceExternalBufferInfo -- ^ pExternalBufferInfo
                                                        ->
                   Ptr VkExternalBufferProperties -- ^ pExternalBufferProperties
                                                  -> IO ()

#else
vkGetPhysicalDeviceExternalBufferPropertiesSafe ::
                                                VkPhysicalDevice -- ^ physicalDevice
                                                                 ->
                                                  Ptr VkPhysicalDeviceExternalBufferInfo -- ^ pExternalBufferInfo
                                                                                         ->
                                                    Ptr VkExternalBufferProperties -- ^ pExternalBufferProperties
                                                                                   -> IO ()
vkGetPhysicalDeviceExternalBufferPropertiesSafe :: VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalBufferInfo
-> Ptr VkExternalBufferProperties
-> IO ()
vkGetPhysicalDeviceExternalBufferPropertiesSafe
  = IO
  (VkPhysicalDevice
   -> Ptr VkPhysicalDeviceExternalBufferInfo
   -> Ptr VkExternalBufferProperties
   -> IO ())
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalBufferInfo
-> Ptr VkExternalBufferProperties
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkGetPhysicalDeviceExternalBufferProperties)

{-# NOINLINE vkGetPhysicalDeviceExternalBufferPropertiesSafe #-}
#endif

-- |
-- > void vkGetPhysicalDeviceExternalBufferProperties
-- >     ( VkPhysicalDevice physicalDevice
-- >     , const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo
-- >     , VkExternalBufferProperties* pExternalBufferProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceExternalBufferProperties <- vkGetInstanceProc @VkGetPhysicalDeviceExternalBufferProperties vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceExternalBufferProperties <- vkGetProc @VkGetPhysicalDeviceExternalBufferProperties
--
-- __Note:__ @vkGetPhysicalDeviceExternalBufferPropertiesUnsafe@ and @vkGetPhysicalDeviceExternalBufferPropertiesSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceExternalBufferProperties@ is an alias
--           of @vkGetPhysicalDeviceExternalBufferPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceExternalBufferPropertiesSafe@.
--
vkGetPhysicalDeviceExternalBufferProperties ::
                                            VkPhysicalDevice -- ^ physicalDevice
                                                             ->
                                              Ptr VkPhysicalDeviceExternalBufferInfo -- ^ pExternalBufferInfo
                                                                                     ->
                                                Ptr VkExternalBufferProperties -- ^ pExternalBufferProperties
                                                                               -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkGetPhysicalDeviceExternalBufferProperties
  = vkGetPhysicalDeviceExternalBufferPropertiesUnsafe
#else
vkGetPhysicalDeviceExternalBufferProperties :: VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalBufferInfo
-> Ptr VkExternalBufferProperties
-> IO ()
vkGetPhysicalDeviceExternalBufferProperties
  = VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalBufferInfo
-> Ptr VkExternalBufferProperties
-> IO ()
vkGetPhysicalDeviceExternalBufferPropertiesSafe

#endif
{-# INLINE vkGetPhysicalDeviceExternalBufferProperties #-}

-- | > void vkGetPhysicalDeviceExternalBufferProperties
--   >     ( VkPhysicalDevice physicalDevice
--   >     , const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo
--   >     , VkExternalBufferProperties* pExternalBufferProperties
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties registry at www.khronos.org>
type HS_vkGetPhysicalDeviceExternalBufferProperties =
     VkPhysicalDevice -- ^ physicalDevice
                      ->
       Ptr VkPhysicalDeviceExternalBufferInfo -- ^ pExternalBufferInfo
                                              ->
         Ptr VkExternalBufferProperties -- ^ pExternalBufferProperties
                                        -> IO ()

type PFN_vkGetPhysicalDeviceExternalBufferProperties =
     FunPtr HS_vkGetPhysicalDeviceExternalBufferProperties

foreign import ccall unsafe "dynamic"
               unwrapVkGetPhysicalDeviceExternalBufferPropertiesUnsafe ::
               PFN_vkGetPhysicalDeviceExternalBufferProperties ->
                 HS_vkGetPhysicalDeviceExternalBufferProperties

foreign import ccall safe "dynamic"
               unwrapVkGetPhysicalDeviceExternalBufferPropertiesSafe ::
               PFN_vkGetPhysicalDeviceExternalBufferProperties ->
                 HS_vkGetPhysicalDeviceExternalBufferProperties

instance VulkanProc "vkGetPhysicalDeviceExternalBufferProperties"
         where
    type VkProcType "vkGetPhysicalDeviceExternalBufferProperties" =
         HS_vkGetPhysicalDeviceExternalBufferProperties
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkGetPhysicalDeviceExternalBufferProperties

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkGetPhysicalDeviceExternalBufferProperties)
-> VkProcType VkGetPhysicalDeviceExternalBufferProperties
unwrapVkProcPtrUnsafe
      = FunPtr (VkProcType VkGetPhysicalDeviceExternalBufferProperties)
-> VkProcType VkGetPhysicalDeviceExternalBufferProperties
PFN_vkGetPhysicalDeviceExternalBufferProperties
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalBufferInfo
-> Ptr VkExternalBufferProperties
-> IO ()
unwrapVkGetPhysicalDeviceExternalBufferPropertiesUnsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkGetPhysicalDeviceExternalBufferProperties)
-> VkProcType VkGetPhysicalDeviceExternalBufferProperties
unwrapVkProcPtrSafe
      = FunPtr (VkProcType VkGetPhysicalDeviceExternalBufferProperties)
-> VkProcType VkGetPhysicalDeviceExternalBufferProperties
PFN_vkGetPhysicalDeviceExternalBufferProperties
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalBufferInfo
-> Ptr VkExternalBufferProperties
-> IO ()
unwrapVkGetPhysicalDeviceExternalBufferPropertiesSafe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO
        :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO
        = VkStructureType 1000071000

pattern VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES :: VkStructureType
$mVK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES =
        VkStructureType 1000071001

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO =
        VkStructureType 1000071002

pattern VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES :: VkStructureType
$mVK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES =
        VkStructureType 1000071003

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES =
        VkStructureType 1000071004

pattern VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO =
        VkStructureType 1000072000

pattern VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO =
        VkStructureType 1000072001

pattern VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO =
        VkStructureType 1000072002

pattern VK_ERROR_INVALID_EXTERNAL_HANDLE :: VkResult

pattern $bVK_ERROR_INVALID_EXTERNAL_HANDLE :: VkResult
$mVK_ERROR_INVALID_EXTERNAL_HANDLE :: forall {r}. VkResult -> (Void# -> r) -> (Void# -> r) -> r
VK_ERROR_INVALID_EXTERNAL_HANDLE = VkResult (-1000072003)

pattern VkGetPhysicalDeviceExternalFenceProperties :: CString

pattern $bVkGetPhysicalDeviceExternalFenceProperties :: CString
$mVkGetPhysicalDeviceExternalFenceProperties :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkGetPhysicalDeviceExternalFenceProperties <-
        (is_VkGetPhysicalDeviceExternalFenceProperties -> True)
  where
    VkGetPhysicalDeviceExternalFenceProperties
      = CString
_VkGetPhysicalDeviceExternalFenceProperties

{-# INLINE _VkGetPhysicalDeviceExternalFenceProperties #-}

_VkGetPhysicalDeviceExternalFenceProperties :: CString
_VkGetPhysicalDeviceExternalFenceProperties :: CString
_VkGetPhysicalDeviceExternalFenceProperties
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkGetPhysicalDeviceExternalFenceProperties\NUL"#

{-# INLINE is_VkGetPhysicalDeviceExternalFenceProperties #-}

is_VkGetPhysicalDeviceExternalFenceProperties :: CString -> Bool
is_VkGetPhysicalDeviceExternalFenceProperties :: CString -> Bool
is_VkGetPhysicalDeviceExternalFenceProperties
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkGetPhysicalDeviceExternalFenceProperties

type VkGetPhysicalDeviceExternalFenceProperties =
     "vkGetPhysicalDeviceExternalFenceProperties"

-- |
-- > void vkGetPhysicalDeviceExternalFenceProperties
-- >     ( VkPhysicalDevice physicalDevice
-- >     , const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo
-- >     , VkExternalFenceProperties* pExternalFenceProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceExternalFenceProperties <- vkGetInstanceProc @VkGetPhysicalDeviceExternalFenceProperties vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceExternalFenceProperties <- vkGetProc @VkGetPhysicalDeviceExternalFenceProperties
--
-- __Note:__ @vkGetPhysicalDeviceExternalFencePropertiesUnsafe@ and @vkGetPhysicalDeviceExternalFencePropertiesSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceExternalFenceProperties@ is an alias
--           of @vkGetPhysicalDeviceExternalFencePropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceExternalFencePropertiesSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe
               "vkGetPhysicalDeviceExternalFenceProperties"
               vkGetPhysicalDeviceExternalFencePropertiesUnsafe ::
               VkPhysicalDevice -- ^ physicalDevice
                                ->
                 Ptr VkPhysicalDeviceExternalFenceInfo -- ^ pExternalFenceInfo
                                                       ->
                   Ptr VkExternalFenceProperties -- ^ pExternalFenceProperties
                                                 -> IO ()

#else
vkGetPhysicalDeviceExternalFencePropertiesUnsafe ::
                                                 VkPhysicalDevice -- ^ physicalDevice
                                                                  ->
                                                   Ptr VkPhysicalDeviceExternalFenceInfo -- ^ pExternalFenceInfo
                                                                                         ->
                                                     Ptr VkExternalFenceProperties -- ^ pExternalFenceProperties
                                                                                   -> IO ()
vkGetPhysicalDeviceExternalFencePropertiesUnsafe :: VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalFenceInfo
-> Ptr VkExternalFenceProperties
-> IO ()
vkGetPhysicalDeviceExternalFencePropertiesUnsafe
  = IO
  (VkPhysicalDevice
   -> Ptr VkPhysicalDeviceExternalFenceInfo
   -> Ptr VkExternalFenceProperties
   -> IO ())
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalFenceInfo
-> Ptr VkExternalFenceProperties
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkGetPhysicalDeviceExternalFenceProperties)

{-# NOINLINE vkGetPhysicalDeviceExternalFencePropertiesUnsafe #-}
#endif

-- |
-- > void vkGetPhysicalDeviceExternalFenceProperties
-- >     ( VkPhysicalDevice physicalDevice
-- >     , const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo
-- >     , VkExternalFenceProperties* pExternalFenceProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceExternalFenceProperties <- vkGetInstanceProc @VkGetPhysicalDeviceExternalFenceProperties vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceExternalFenceProperties <- vkGetProc @VkGetPhysicalDeviceExternalFenceProperties
--
-- __Note:__ @vkGetPhysicalDeviceExternalFencePropertiesUnsafe@ and @vkGetPhysicalDeviceExternalFencePropertiesSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceExternalFenceProperties@ is an alias
--           of @vkGetPhysicalDeviceExternalFencePropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceExternalFencePropertiesSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe
               "vkGetPhysicalDeviceExternalFenceProperties"
               vkGetPhysicalDeviceExternalFencePropertiesSafe ::
               VkPhysicalDevice -- ^ physicalDevice
                                ->
                 Ptr VkPhysicalDeviceExternalFenceInfo -- ^ pExternalFenceInfo
                                                       ->
                   Ptr VkExternalFenceProperties -- ^ pExternalFenceProperties
                                                 -> IO ()

#else
vkGetPhysicalDeviceExternalFencePropertiesSafe ::
                                               VkPhysicalDevice -- ^ physicalDevice
                                                                ->
                                                 Ptr VkPhysicalDeviceExternalFenceInfo -- ^ pExternalFenceInfo
                                                                                       ->
                                                   Ptr VkExternalFenceProperties -- ^ pExternalFenceProperties
                                                                                 -> IO ()
vkGetPhysicalDeviceExternalFencePropertiesSafe :: VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalFenceInfo
-> Ptr VkExternalFenceProperties
-> IO ()
vkGetPhysicalDeviceExternalFencePropertiesSafe
  = IO
  (VkPhysicalDevice
   -> Ptr VkPhysicalDeviceExternalFenceInfo
   -> Ptr VkExternalFenceProperties
   -> IO ())
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalFenceInfo
-> Ptr VkExternalFenceProperties
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkGetPhysicalDeviceExternalFenceProperties)

{-# NOINLINE vkGetPhysicalDeviceExternalFencePropertiesSafe #-}
#endif

-- |
-- > void vkGetPhysicalDeviceExternalFenceProperties
-- >     ( VkPhysicalDevice physicalDevice
-- >     , const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo
-- >     , VkExternalFenceProperties* pExternalFenceProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceExternalFenceProperties <- vkGetInstanceProc @VkGetPhysicalDeviceExternalFenceProperties vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceExternalFenceProperties <- vkGetProc @VkGetPhysicalDeviceExternalFenceProperties
--
-- __Note:__ @vkGetPhysicalDeviceExternalFencePropertiesUnsafe@ and @vkGetPhysicalDeviceExternalFencePropertiesSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceExternalFenceProperties@ is an alias
--           of @vkGetPhysicalDeviceExternalFencePropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceExternalFencePropertiesSafe@.
--
vkGetPhysicalDeviceExternalFenceProperties ::
                                           VkPhysicalDevice -- ^ physicalDevice
                                                            ->
                                             Ptr VkPhysicalDeviceExternalFenceInfo -- ^ pExternalFenceInfo
                                                                                   ->
                                               Ptr VkExternalFenceProperties -- ^ pExternalFenceProperties
                                                                             -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkGetPhysicalDeviceExternalFenceProperties
  = vkGetPhysicalDeviceExternalFencePropertiesUnsafe
#else
vkGetPhysicalDeviceExternalFenceProperties :: VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalFenceInfo
-> Ptr VkExternalFenceProperties
-> IO ()
vkGetPhysicalDeviceExternalFenceProperties
  = VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalFenceInfo
-> Ptr VkExternalFenceProperties
-> IO ()
vkGetPhysicalDeviceExternalFencePropertiesSafe

#endif
{-# INLINE vkGetPhysicalDeviceExternalFenceProperties #-}

-- | > void vkGetPhysicalDeviceExternalFenceProperties
--   >     ( VkPhysicalDevice physicalDevice
--   >     , const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo
--   >     , VkExternalFenceProperties* pExternalFenceProperties
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties registry at www.khronos.org>
type HS_vkGetPhysicalDeviceExternalFenceProperties =
     VkPhysicalDevice -- ^ physicalDevice
                      ->
       Ptr VkPhysicalDeviceExternalFenceInfo -- ^ pExternalFenceInfo
                                             ->
         Ptr VkExternalFenceProperties -- ^ pExternalFenceProperties
                                       -> IO ()

type PFN_vkGetPhysicalDeviceExternalFenceProperties =
     FunPtr HS_vkGetPhysicalDeviceExternalFenceProperties

foreign import ccall unsafe "dynamic"
               unwrapVkGetPhysicalDeviceExternalFencePropertiesUnsafe ::
               PFN_vkGetPhysicalDeviceExternalFenceProperties ->
                 HS_vkGetPhysicalDeviceExternalFenceProperties

foreign import ccall safe "dynamic"
               unwrapVkGetPhysicalDeviceExternalFencePropertiesSafe ::
               PFN_vkGetPhysicalDeviceExternalFenceProperties ->
                 HS_vkGetPhysicalDeviceExternalFenceProperties

instance VulkanProc "vkGetPhysicalDeviceExternalFenceProperties"
         where
    type VkProcType "vkGetPhysicalDeviceExternalFenceProperties" =
         HS_vkGetPhysicalDeviceExternalFenceProperties
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkGetPhysicalDeviceExternalFenceProperties

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkGetPhysicalDeviceExternalFenceProperties)
-> VkProcType VkGetPhysicalDeviceExternalFenceProperties
unwrapVkProcPtrUnsafe
      = FunPtr (VkProcType VkGetPhysicalDeviceExternalFenceProperties)
-> VkProcType VkGetPhysicalDeviceExternalFenceProperties
PFN_vkGetPhysicalDeviceExternalFenceProperties
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalFenceInfo
-> Ptr VkExternalFenceProperties
-> IO ()
unwrapVkGetPhysicalDeviceExternalFencePropertiesUnsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkGetPhysicalDeviceExternalFenceProperties)
-> VkProcType VkGetPhysicalDeviceExternalFenceProperties
unwrapVkProcPtrSafe
      = FunPtr (VkProcType VkGetPhysicalDeviceExternalFenceProperties)
-> VkProcType VkGetPhysicalDeviceExternalFenceProperties
PFN_vkGetPhysicalDeviceExternalFenceProperties
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalFenceInfo
-> Ptr VkExternalFenceProperties
-> IO ()
unwrapVkGetPhysicalDeviceExternalFencePropertiesSafe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO =
        VkStructureType 1000112000

pattern VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES :: VkStructureType
$mVK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES =
        VkStructureType 1000112001

pattern VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO =
        VkStructureType 1000113000

pattern VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO =
        VkStructureType 1000077000

pattern VkGetPhysicalDeviceExternalSemaphoreProperties :: CString

pattern $bVkGetPhysicalDeviceExternalSemaphoreProperties :: CString
$mVkGetPhysicalDeviceExternalSemaphoreProperties :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkGetPhysicalDeviceExternalSemaphoreProperties <-
        (is_VkGetPhysicalDeviceExternalSemaphoreProperties -> True)
  where
    VkGetPhysicalDeviceExternalSemaphoreProperties
      = CString
_VkGetPhysicalDeviceExternalSemaphoreProperties

{-# INLINE _VkGetPhysicalDeviceExternalSemaphoreProperties #-}

_VkGetPhysicalDeviceExternalSemaphoreProperties :: CString
_VkGetPhysicalDeviceExternalSemaphoreProperties :: CString
_VkGetPhysicalDeviceExternalSemaphoreProperties
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkGetPhysicalDeviceExternalSemaphoreProperties\NUL"#

{-# INLINE is_VkGetPhysicalDeviceExternalSemaphoreProperties #-}

is_VkGetPhysicalDeviceExternalSemaphoreProperties ::
                                                  CString -> Bool
is_VkGetPhysicalDeviceExternalSemaphoreProperties :: CString -> Bool
is_VkGetPhysicalDeviceExternalSemaphoreProperties
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      CString -> CString -> Ordering
cmpCStrings CString
_VkGetPhysicalDeviceExternalSemaphoreProperties

type VkGetPhysicalDeviceExternalSemaphoreProperties =
     "vkGetPhysicalDeviceExternalSemaphoreProperties"

-- |
-- > void vkGetPhysicalDeviceExternalSemaphoreProperties
-- >     ( VkPhysicalDevice physicalDevice
-- >     , const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo
-- >     , VkExternalSemaphoreProperties* pExternalSemaphoreProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceExternalSemaphoreProperties <- vkGetInstanceProc @VkGetPhysicalDeviceExternalSemaphoreProperties vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceExternalSemaphoreProperties <- vkGetProc @VkGetPhysicalDeviceExternalSemaphoreProperties
--
-- __Note:__ @vkGetPhysicalDeviceExternalSemaphorePropertiesUnsafe@ and @vkGetPhysicalDeviceExternalSemaphorePropertiesSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceExternalSemaphoreProperties@ is an alias
--           of @vkGetPhysicalDeviceExternalSemaphorePropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceExternalSemaphorePropertiesSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe
               "vkGetPhysicalDeviceExternalSemaphoreProperties"
               vkGetPhysicalDeviceExternalSemaphorePropertiesUnsafe ::
               VkPhysicalDevice -- ^ physicalDevice
                                ->
                 Ptr VkPhysicalDeviceExternalSemaphoreInfo -- ^ pExternalSemaphoreInfo
                                                           ->
                   Ptr VkExternalSemaphoreProperties -- ^ pExternalSemaphoreProperties
                                                     -> IO ()

#else
vkGetPhysicalDeviceExternalSemaphorePropertiesUnsafe ::
                                                     VkPhysicalDevice -- ^ physicalDevice
                                                                      ->
                                                       Ptr VkPhysicalDeviceExternalSemaphoreInfo -- ^ pExternalSemaphoreInfo
                                                                                                 ->
                                                         Ptr VkExternalSemaphoreProperties -- ^ pExternalSemaphoreProperties
                                                                                           -> IO ()
vkGetPhysicalDeviceExternalSemaphorePropertiesUnsafe :: VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalSemaphoreInfo
-> Ptr VkExternalSemaphoreProperties
-> IO ()
vkGetPhysicalDeviceExternalSemaphorePropertiesUnsafe
  = IO
  (VkPhysicalDevice
   -> Ptr VkPhysicalDeviceExternalSemaphoreInfo
   -> Ptr VkExternalSemaphoreProperties
   -> IO ())
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalSemaphoreInfo
-> Ptr VkExternalSemaphoreProperties
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkGetPhysicalDeviceExternalSemaphoreProperties)

{-# NOINLINE vkGetPhysicalDeviceExternalSemaphorePropertiesUnsafe
             #-}
#endif

-- |
-- > void vkGetPhysicalDeviceExternalSemaphoreProperties
-- >     ( VkPhysicalDevice physicalDevice
-- >     , const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo
-- >     , VkExternalSemaphoreProperties* pExternalSemaphoreProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceExternalSemaphoreProperties <- vkGetInstanceProc @VkGetPhysicalDeviceExternalSemaphoreProperties vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceExternalSemaphoreProperties <- vkGetProc @VkGetPhysicalDeviceExternalSemaphoreProperties
--
-- __Note:__ @vkGetPhysicalDeviceExternalSemaphorePropertiesUnsafe@ and @vkGetPhysicalDeviceExternalSemaphorePropertiesSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceExternalSemaphoreProperties@ is an alias
--           of @vkGetPhysicalDeviceExternalSemaphorePropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceExternalSemaphorePropertiesSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe
               "vkGetPhysicalDeviceExternalSemaphoreProperties"
               vkGetPhysicalDeviceExternalSemaphorePropertiesSafe ::
               VkPhysicalDevice -- ^ physicalDevice
                                ->
                 Ptr VkPhysicalDeviceExternalSemaphoreInfo -- ^ pExternalSemaphoreInfo
                                                           ->
                   Ptr VkExternalSemaphoreProperties -- ^ pExternalSemaphoreProperties
                                                     -> IO ()

#else
vkGetPhysicalDeviceExternalSemaphorePropertiesSafe ::
                                                   VkPhysicalDevice -- ^ physicalDevice
                                                                    ->
                                                     Ptr VkPhysicalDeviceExternalSemaphoreInfo -- ^ pExternalSemaphoreInfo
                                                                                               ->
                                                       Ptr VkExternalSemaphoreProperties -- ^ pExternalSemaphoreProperties
                                                                                         -> IO ()
vkGetPhysicalDeviceExternalSemaphorePropertiesSafe :: VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalSemaphoreInfo
-> Ptr VkExternalSemaphoreProperties
-> IO ()
vkGetPhysicalDeviceExternalSemaphorePropertiesSafe
  = IO
  (VkPhysicalDevice
   -> Ptr VkPhysicalDeviceExternalSemaphoreInfo
   -> Ptr VkExternalSemaphoreProperties
   -> IO ())
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalSemaphoreInfo
-> Ptr VkExternalSemaphoreProperties
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkGetPhysicalDeviceExternalSemaphoreProperties)

{-# NOINLINE vkGetPhysicalDeviceExternalSemaphorePropertiesSafe #-}
#endif

-- |
-- > void vkGetPhysicalDeviceExternalSemaphoreProperties
-- >     ( VkPhysicalDevice physicalDevice
-- >     , const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo
-- >     , VkExternalSemaphoreProperties* pExternalSemaphoreProperties
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetPhysicalDeviceExternalSemaphoreProperties <- vkGetInstanceProc @VkGetPhysicalDeviceExternalSemaphoreProperties vkInstance
--
-- or less efficient:
--
-- > myGetPhysicalDeviceExternalSemaphoreProperties <- vkGetProc @VkGetPhysicalDeviceExternalSemaphoreProperties
--
-- __Note:__ @vkGetPhysicalDeviceExternalSemaphorePropertiesUnsafe@ and @vkGetPhysicalDeviceExternalSemaphorePropertiesSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetPhysicalDeviceExternalSemaphoreProperties@ is an alias
--           of @vkGetPhysicalDeviceExternalSemaphorePropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceExternalSemaphorePropertiesSafe@.
--
vkGetPhysicalDeviceExternalSemaphoreProperties ::
                                               VkPhysicalDevice -- ^ physicalDevice
                                                                ->
                                                 Ptr VkPhysicalDeviceExternalSemaphoreInfo -- ^ pExternalSemaphoreInfo
                                                                                           ->
                                                   Ptr VkExternalSemaphoreProperties -- ^ pExternalSemaphoreProperties
                                                                                     -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkGetPhysicalDeviceExternalSemaphoreProperties
  = vkGetPhysicalDeviceExternalSemaphorePropertiesUnsafe
#else
vkGetPhysicalDeviceExternalSemaphoreProperties :: VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalSemaphoreInfo
-> Ptr VkExternalSemaphoreProperties
-> IO ()
vkGetPhysicalDeviceExternalSemaphoreProperties
  = VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalSemaphoreInfo
-> Ptr VkExternalSemaphoreProperties
-> IO ()
vkGetPhysicalDeviceExternalSemaphorePropertiesSafe

#endif
{-# INLINE vkGetPhysicalDeviceExternalSemaphoreProperties #-}

-- | > void vkGetPhysicalDeviceExternalSemaphoreProperties
--   >     ( VkPhysicalDevice physicalDevice
--   >     , const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo
--   >     , VkExternalSemaphoreProperties* pExternalSemaphoreProperties
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties registry at www.khronos.org>
type HS_vkGetPhysicalDeviceExternalSemaphoreProperties =
     VkPhysicalDevice -- ^ physicalDevice
                      ->
       Ptr VkPhysicalDeviceExternalSemaphoreInfo -- ^ pExternalSemaphoreInfo
                                                 ->
         Ptr VkExternalSemaphoreProperties -- ^ pExternalSemaphoreProperties
                                           -> IO ()

type PFN_vkGetPhysicalDeviceExternalSemaphoreProperties =
     FunPtr HS_vkGetPhysicalDeviceExternalSemaphoreProperties

foreign import ccall unsafe "dynamic"
               unwrapVkGetPhysicalDeviceExternalSemaphorePropertiesUnsafe ::
               PFN_vkGetPhysicalDeviceExternalSemaphoreProperties ->
                 HS_vkGetPhysicalDeviceExternalSemaphoreProperties

foreign import ccall safe "dynamic"
               unwrapVkGetPhysicalDeviceExternalSemaphorePropertiesSafe ::
               PFN_vkGetPhysicalDeviceExternalSemaphoreProperties ->
                 HS_vkGetPhysicalDeviceExternalSemaphoreProperties

instance VulkanProc
           "vkGetPhysicalDeviceExternalSemaphoreProperties"
         where
    type VkProcType "vkGetPhysicalDeviceExternalSemaphoreProperties" =
         HS_vkGetPhysicalDeviceExternalSemaphoreProperties
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkGetPhysicalDeviceExternalSemaphoreProperties

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkGetPhysicalDeviceExternalSemaphoreProperties)
-> VkProcType VkGetPhysicalDeviceExternalSemaphoreProperties
unwrapVkProcPtrUnsafe
      = FunPtr (VkProcType VkGetPhysicalDeviceExternalSemaphoreProperties)
-> VkProcType VkGetPhysicalDeviceExternalSemaphoreProperties
PFN_vkGetPhysicalDeviceExternalSemaphoreProperties
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalSemaphoreInfo
-> Ptr VkExternalSemaphoreProperties
-> IO ()
unwrapVkGetPhysicalDeviceExternalSemaphorePropertiesUnsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkGetPhysicalDeviceExternalSemaphoreProperties)
-> VkProcType VkGetPhysicalDeviceExternalSemaphoreProperties
unwrapVkProcPtrSafe
      = FunPtr (VkProcType VkGetPhysicalDeviceExternalSemaphoreProperties)
-> VkProcType VkGetPhysicalDeviceExternalSemaphoreProperties
PFN_vkGetPhysicalDeviceExternalSemaphoreProperties
-> VkPhysicalDevice
-> Ptr VkPhysicalDeviceExternalSemaphoreInfo
-> Ptr VkExternalSemaphoreProperties
-> IO ()
unwrapVkGetPhysicalDeviceExternalSemaphorePropertiesSafe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO
        :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO =
        VkStructureType 1000076000

pattern VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES :: VkStructureType
$mVK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES =
        VkStructureType 1000076001

pattern VkGetDescriptorSetLayoutSupport :: CString

pattern $bVkGetDescriptorSetLayoutSupport :: CString
$mVkGetDescriptorSetLayoutSupport :: forall {r}. CString -> (Void# -> r) -> (Void# -> r) -> r
VkGetDescriptorSetLayoutSupport <-
        (is_VkGetDescriptorSetLayoutSupport -> True)
  where
    VkGetDescriptorSetLayoutSupport = CString
_VkGetDescriptorSetLayoutSupport

{-# INLINE _VkGetDescriptorSetLayoutSupport #-}

_VkGetDescriptorSetLayoutSupport :: CString
_VkGetDescriptorSetLayoutSupport :: CString
_VkGetDescriptorSetLayoutSupport
  = Addr# -> CString
forall a. Addr# -> Ptr a
Ptr Addr#
"vkGetDescriptorSetLayoutSupport\NUL"#

{-# INLINE is_VkGetDescriptorSetLayoutSupport #-}

is_VkGetDescriptorSetLayoutSupport :: CString -> Bool
is_VkGetDescriptorSetLayoutSupport :: CString -> Bool
is_VkGetDescriptorSetLayoutSupport
  = (Ordering
EQ Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
==) (Ordering -> Bool) -> (CString -> Ordering) -> CString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CString -> CString -> Ordering
cmpCStrings CString
_VkGetDescriptorSetLayoutSupport

type VkGetDescriptorSetLayoutSupport =
     "vkGetDescriptorSetLayoutSupport"

-- |
-- > void vkGetDescriptorSetLayoutSupport
-- >     ( VkDevice device
-- >     , const VkDescriptorSetLayoutCreateInfo* pCreateInfo
-- >     , VkDescriptorSetLayoutSupport* pSupport
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetDescriptorSetLayoutSupport <- vkGetDeviceProc @VkGetDescriptorSetLayoutSupport vkDevice
--
-- or less efficient:
--
-- > myGetDescriptorSetLayoutSupport <- vkGetProc @VkGetDescriptorSetLayoutSupport
--
-- __Note:__ @vkGetDescriptorSetLayoutSupportUnsafe@ and @vkGetDescriptorSetLayoutSupportSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetDescriptorSetLayoutSupport@ is an alias
--           of @vkGetDescriptorSetLayoutSupportUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetDescriptorSetLayoutSupportSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall unsafe "vkGetDescriptorSetLayoutSupport"
               vkGetDescriptorSetLayoutSupportUnsafe ::
               VkDevice -- ^ device
                        ->
                 Ptr VkDescriptorSetLayoutCreateInfo -- ^ pCreateInfo
                                                     ->
                   Ptr VkDescriptorSetLayoutSupport -- ^ pSupport
                                                    -> IO ()

#else
vkGetDescriptorSetLayoutSupportUnsafe ::
                                      VkDevice -- ^ device
                                               ->
                                        Ptr VkDescriptorSetLayoutCreateInfo -- ^ pCreateInfo
                                                                            ->
                                          Ptr VkDescriptorSetLayoutSupport -- ^ pSupport
                                                                           -> IO ()
vkGetDescriptorSetLayoutSupportUnsafe :: VkDevice
-> Ptr VkDescriptorSetLayoutCreateInfo
-> Ptr VkDescriptorSetLayoutSupport
-> IO ()
vkGetDescriptorSetLayoutSupportUnsafe
  = IO
  (VkDevice
   -> Ptr VkDescriptorSetLayoutCreateInfo
   -> Ptr VkDescriptorSetLayoutSupport
   -> IO ())
-> VkDevice
-> Ptr VkDescriptorSetLayoutCreateInfo
-> Ptr VkDescriptorSetLayoutSupport
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcUnsafe @VkGetDescriptorSetLayoutSupport)

{-# NOINLINE vkGetDescriptorSetLayoutSupportUnsafe #-}
#endif

-- |
-- > void vkGetDescriptorSetLayoutSupport
-- >     ( VkDevice device
-- >     , const VkDescriptorSetLayoutCreateInfo* pCreateInfo
-- >     , VkDescriptorSetLayoutSupport* pSupport
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetDescriptorSetLayoutSupport <- vkGetDeviceProc @VkGetDescriptorSetLayoutSupport vkDevice
--
-- or less efficient:
--
-- > myGetDescriptorSetLayoutSupport <- vkGetProc @VkGetDescriptorSetLayoutSupport
--
-- __Note:__ @vkGetDescriptorSetLayoutSupportUnsafe@ and @vkGetDescriptorSetLayoutSupportSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetDescriptorSetLayoutSupport@ is an alias
--           of @vkGetDescriptorSetLayoutSupportUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetDescriptorSetLayoutSupportSafe@.
--
--
#ifdef NATIVE_FFI_VK_VERSION_1_1
foreign import ccall safe "vkGetDescriptorSetLayoutSupport"
               vkGetDescriptorSetLayoutSupportSafe ::
               VkDevice -- ^ device
                        ->
                 Ptr VkDescriptorSetLayoutCreateInfo -- ^ pCreateInfo
                                                     ->
                   Ptr VkDescriptorSetLayoutSupport -- ^ pSupport
                                                    -> IO ()

#else
vkGetDescriptorSetLayoutSupportSafe ::
                                    VkDevice -- ^ device
                                             ->
                                      Ptr VkDescriptorSetLayoutCreateInfo -- ^ pCreateInfo
                                                                          ->
                                        Ptr VkDescriptorSetLayoutSupport -- ^ pSupport
                                                                         -> IO ()
vkGetDescriptorSetLayoutSupportSafe :: VkDevice
-> Ptr VkDescriptorSetLayoutCreateInfo
-> Ptr VkDescriptorSetLayoutSupport
-> IO ()
vkGetDescriptorSetLayoutSupportSafe
  = IO
  (VkDevice
   -> Ptr VkDescriptorSetLayoutCreateInfo
   -> Ptr VkDescriptorSetLayoutSupport
   -> IO ())
-> VkDevice
-> Ptr VkDescriptorSetLayoutCreateInfo
-> Ptr VkDescriptorSetLayoutSupport
-> IO ()
forall a. IO a -> a
unsafeDupablePerformIO
      (forall (proc :: Symbol). VulkanProc proc => IO (VkProcType proc)
vkGetProcSafe @VkGetDescriptorSetLayoutSupport)

{-# NOINLINE vkGetDescriptorSetLayoutSupportSafe #-}
#endif

-- |
-- > void vkGetDescriptorSetLayoutSupport
-- >     ( VkDevice device
-- >     , const VkDescriptorSetLayoutCreateInfo* pCreateInfo
-- >     , VkDescriptorSetLayoutSupport* pSupport
-- >     )
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport registry at www.khronos.org>
--
-- __Note:__ When @useNativeFFI-1-1@ cabal flag is enabled, this function is linked statically
--           as a @foreign import@ call to C Vulkan loader.
--           Otherwise, it is looked up dynamically at runtime using dlsym-like machinery (platform-dependent).
--
-- Independently of the flag setting, you can lookup the function manually at runtime:
--
-- > myGetDescriptorSetLayoutSupport <- vkGetDeviceProc @VkGetDescriptorSetLayoutSupport vkDevice
--
-- or less efficient:
--
-- > myGetDescriptorSetLayoutSupport <- vkGetProc @VkGetDescriptorSetLayoutSupport
--
-- __Note:__ @vkGetDescriptorSetLayoutSupportUnsafe@ and @vkGetDescriptorSetLayoutSupportSafe@ are the @unsafe@ and @safe@
--           FFI imports of this function, respectively. @vkGetDescriptorSetLayoutSupport@ is an alias
--           of @vkGetDescriptorSetLayoutSupportUnsafe@ when the @useUnsafeFFIDefault@ cabal flag
--           is enabled; otherwise, it is an alias of @vkGetDescriptorSetLayoutSupportSafe@.
--
vkGetDescriptorSetLayoutSupport ::
                                VkDevice -- ^ device
                                         ->
                                  Ptr VkDescriptorSetLayoutCreateInfo -- ^ pCreateInfo
                                                                      ->
                                    Ptr VkDescriptorSetLayoutSupport -- ^ pSupport
                                                                     -> IO ()
#ifdef UNSAFE_FFI_DEFAULT
vkGetDescriptorSetLayoutSupport
  = vkGetDescriptorSetLayoutSupportUnsafe
#else
vkGetDescriptorSetLayoutSupport :: VkDevice
-> Ptr VkDescriptorSetLayoutCreateInfo
-> Ptr VkDescriptorSetLayoutSupport
-> IO ()
vkGetDescriptorSetLayoutSupport
  = VkDevice
-> Ptr VkDescriptorSetLayoutCreateInfo
-> Ptr VkDescriptorSetLayoutSupport
-> IO ()
vkGetDescriptorSetLayoutSupportSafe

#endif
{-# INLINE vkGetDescriptorSetLayoutSupport #-}

-- | > void vkGetDescriptorSetLayoutSupport
--   >     ( VkDevice device
--   >     , const VkDescriptorSetLayoutCreateInfo* pCreateInfo
--   >     , VkDescriptorSetLayoutSupport* pSupport
--   >     )
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport registry at www.khronos.org>
type HS_vkGetDescriptorSetLayoutSupport =
     VkDevice -- ^ device
              ->
       Ptr VkDescriptorSetLayoutCreateInfo -- ^ pCreateInfo
                                           ->
         Ptr VkDescriptorSetLayoutSupport -- ^ pSupport
                                          -> IO ()

type PFN_vkGetDescriptorSetLayoutSupport =
     FunPtr HS_vkGetDescriptorSetLayoutSupport

foreign import ccall unsafe "dynamic"
               unwrapVkGetDescriptorSetLayoutSupportUnsafe ::
               PFN_vkGetDescriptorSetLayoutSupport ->
                 HS_vkGetDescriptorSetLayoutSupport

foreign import ccall safe "dynamic"
               unwrapVkGetDescriptorSetLayoutSupportSafe ::
               PFN_vkGetDescriptorSetLayoutSupport ->
                 HS_vkGetDescriptorSetLayoutSupport

instance VulkanProc "vkGetDescriptorSetLayoutSupport" where
    type VkProcType "vkGetDescriptorSetLayoutSupport" =
         HS_vkGetDescriptorSetLayoutSupport
    vkProcSymbol :: CString
vkProcSymbol = CString
_VkGetDescriptorSetLayoutSupport

    {-# INLINE vkProcSymbol #-}
    unwrapVkProcPtrUnsafe :: FunPtr (VkProcType VkGetDescriptorSetLayoutSupport)
-> VkProcType VkGetDescriptorSetLayoutSupport
unwrapVkProcPtrUnsafe = FunPtr (VkProcType VkGetDescriptorSetLayoutSupport)
-> VkProcType VkGetDescriptorSetLayoutSupport
PFN_vkGetDescriptorSetLayoutSupport
-> VkDevice
-> Ptr VkDescriptorSetLayoutCreateInfo
-> Ptr VkDescriptorSetLayoutSupport
-> IO ()
unwrapVkGetDescriptorSetLayoutSupportUnsafe

    {-# INLINE unwrapVkProcPtrUnsafe #-}
    unwrapVkProcPtrSafe :: FunPtr (VkProcType VkGetDescriptorSetLayoutSupport)
-> VkProcType VkGetDescriptorSetLayoutSupport
unwrapVkProcPtrSafe = FunPtr (VkProcType VkGetDescriptorSetLayoutSupport)
-> VkProcType VkGetDescriptorSetLayoutSupport
PFN_vkGetDescriptorSetLayoutSupport
-> VkDevice
-> Ptr VkDescriptorSetLayoutCreateInfo
-> Ptr VkDescriptorSetLayoutSupport
-> IO ()
unwrapVkGetDescriptorSetLayoutSupportSafe

    {-# INLINE unwrapVkProcPtrSafe #-}

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES
        :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES
        = VkStructureType 1000168000

pattern VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT ::
        VkStructureType

pattern $bVK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT :: VkStructureType
$mVK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT =
        VkStructureType 1000168001

pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES
        :: VkStructureType

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES
        = VkStructureType 1000063000

pattern $bVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES :: VkStructureType
$mVK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES :: forall {r}. VkStructureType -> (Void# -> r) -> (Void# -> r) -> r
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES
        = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES