{-# LINE 1 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} {-# 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_0 (AHardwareBuffer(), ANativeWindow(), CAMetalLayer(), VkBool32(..), VkDeviceAddress(..), VkDeviceSize(..), VkFlags(..), VkSampleMask(..), VkExtent2D, VkExtent3D, VkOffset2D, VkOffset3D, VkRect2D, VkResult(..), VkStructureType(..), -- > ##include "vk_platform.h" -- -- ** These types are part of the API, though not directly used in API commands or data structures VkAccessBitmask(..), VkAccessFlagBits(), VkAccessFlags(), VkBaseInStructure, VkBaseOutStructure, VkBufferMemoryBarrier, VkDispatchIndirectCommand, VkDrawIndexedIndirectCommand, VkDrawIndirectCommand, VkImageAspectBitmask(..), VkImageCreateBitmask(..), VkImageLayout(..), VkImageTiling(..), VkImageType(..), VkImageUsageBitmask(..), VkImageViewType(..), VkImageAspectFlagBits(), VkImageAspectFlags(), VkImageCreateFlagBits(), VkImageCreateFlags(), VkImageUsageFlagBits(), VkImageUsageFlags(), VkImageViewCreateBitmask(..), VkImageViewCreateFlagBits(), VkImageViewCreateFlags(), VkImageMemoryBarrier, VkImageSubresourceRange, VkMemoryBarrier, VkObjectType(..), VkVendorId(..), -- > ##include "vk_platform.h" -- -- ** API version macros -- -- ** API constants VkPipelineBindPoint(..), VkPipelineCacheHeaderVersion(..), VkPipelineCreateBitmask(..), VkPipelineCreationFeedbackBitmaskEXT(..), VkPipelineExecutableStatisticFormatKHR(..), VkPipelineStageBitmask(..), VkPipelineCacheCreateBitmask(..), VkPipelineCacheCreateFlagBits(), VkPipelineCacheCreateFlags(), VkPipelineCompilerControlBitmaskAMD(..), VkPipelineCompilerControlFlagBitsAMD(), VkPipelineCompilerControlFlagsAMD(), VkPipelineCreateFlagBits(), VkPipelineCreateFlags(), VkPipelineCreationFeedbackFlagBitsEXT(), VkPipelineCreationFeedbackFlagsEXT(), VkPipelineShaderStageCreateBitmask(..), VkPipelineShaderStageCreateFlagBits(), VkPipelineShaderStageCreateFlags(), VkPipelineStageFlagBits(), VkPipelineStageFlags(), pattern VK_ATTACHMENT_UNUSED, pattern VK_FALSE, pattern VK_LOD_CLAMP_NONE, pattern VK_QUEUE_FAMILY_IGNORED, pattern VK_REMAINING_ARRAY_LAYERS, pattern VK_REMAINING_MIP_LEVELS, pattern VK_SUBPASS_EXTERNAL, pattern VK_TRUE, pattern VK_WHOLE_SIZE, -- ** Device initialization module Graphics.Vulkan.Marshal, VkAllocationCallbacks, VkApplicationInfo, VkFormat(..), VkFormatFeatureBitmask(..), VkFormatFeatureFlagBits(), VkFormatFeatureFlags(), VkFormatProperties, VkImageFormatProperties, 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(..), VkInstanceCreateInfo, VkInternalAllocationType(..), VkMemoryHeap, VkMemoryAllocateBitmask(..), VkMemoryHeapBitmask(..), VkMemoryOverallocationBehaviorAMD(..), VkMemoryPropertyBitmask(..), VkMemoryAllocateFlagBits(), VkMemoryAllocateFlagBitsKHR(..), VkMemoryAllocateFlags(), VkMemoryHeapFlagBits(), VkMemoryHeapFlags(), VkMemoryPropertyFlagBits(), VkMemoryPropertyFlags(), VkMemoryType, VkPhysicalDeviceFeatures, VkPhysicalDeviceLimits, VkPhysicalDeviceMemoryProperties, VkPhysicalDeviceProperties, VkPhysicalDeviceSparseProperties, VkPhysicalDeviceType(..), VkQueueFamilyProperties, VkQueueBitmask(..), VkQueueGlobalPriorityEXT(..), VkQueueFlagBits(), VkQueueFlags(), VkSampleCountBitmask(..), VkSampleCountFlagBits(), VkSampleCountFlags(), VkSystemAllocationScope(..), -- > ##include "vk_platform.h" VkCreateInstance, pattern VkCreateInstance, HS_vkCreateInstance, PFN_vkCreateInstance, vkCreateInstance, vkCreateInstanceUnsafe, vkCreateInstanceSafe, VkDestroyInstance, pattern VkDestroyInstance, HS_vkDestroyInstance, PFN_vkDestroyInstance, vkDestroyInstance, vkDestroyInstanceUnsafe, vkDestroyInstanceSafe, VkEnumeratePhysicalDevices, pattern VkEnumeratePhysicalDevices, HS_vkEnumeratePhysicalDevices, PFN_vkEnumeratePhysicalDevices, vkEnumeratePhysicalDevices, vkEnumeratePhysicalDevicesUnsafe, vkEnumeratePhysicalDevicesSafe, VkGetPhysicalDeviceFeatures, pattern VkGetPhysicalDeviceFeatures, HS_vkGetPhysicalDeviceFeatures, PFN_vkGetPhysicalDeviceFeatures, vkGetPhysicalDeviceFeatures, vkGetPhysicalDeviceFeaturesUnsafe, vkGetPhysicalDeviceFeaturesSafe, VkGetPhysicalDeviceFormatProperties, pattern VkGetPhysicalDeviceFormatProperties, HS_vkGetPhysicalDeviceFormatProperties, PFN_vkGetPhysicalDeviceFormatProperties, vkGetPhysicalDeviceFormatProperties, vkGetPhysicalDeviceFormatPropertiesUnsafe, vkGetPhysicalDeviceFormatPropertiesSafe, VkGetPhysicalDeviceImageFormatProperties, pattern VkGetPhysicalDeviceImageFormatProperties, HS_vkGetPhysicalDeviceImageFormatProperties, PFN_vkGetPhysicalDeviceImageFormatProperties, vkGetPhysicalDeviceImageFormatProperties, vkGetPhysicalDeviceImageFormatPropertiesUnsafe, vkGetPhysicalDeviceImageFormatPropertiesSafe, VkGetPhysicalDeviceProperties, pattern VkGetPhysicalDeviceProperties, HS_vkGetPhysicalDeviceProperties, PFN_vkGetPhysicalDeviceProperties, vkGetPhysicalDeviceProperties, vkGetPhysicalDevicePropertiesUnsafe, vkGetPhysicalDevicePropertiesSafe, VkGetPhysicalDeviceQueueFamilyProperties, pattern VkGetPhysicalDeviceQueueFamilyProperties, HS_vkGetPhysicalDeviceQueueFamilyProperties, PFN_vkGetPhysicalDeviceQueueFamilyProperties, vkGetPhysicalDeviceQueueFamilyProperties, vkGetPhysicalDeviceQueueFamilyPropertiesUnsafe, vkGetPhysicalDeviceQueueFamilyPropertiesSafe, VkGetPhysicalDeviceMemoryProperties, pattern VkGetPhysicalDeviceMemoryProperties, HS_vkGetPhysicalDeviceMemoryProperties, PFN_vkGetPhysicalDeviceMemoryProperties, vkGetPhysicalDeviceMemoryProperties, vkGetPhysicalDeviceMemoryPropertiesUnsafe, vkGetPhysicalDeviceMemoryPropertiesSafe, VkGetInstanceProcAddr, pattern VkGetInstanceProcAddr, HS_vkGetInstanceProcAddr, PFN_vkGetInstanceProcAddr, vkGetInstanceProcAddr, vkGetInstanceProcAddrUnsafe, vkGetInstanceProcAddrSafe, VkGetDeviceProcAddr, pattern VkGetDeviceProcAddr, HS_vkGetDeviceProcAddr, PFN_vkGetDeviceProcAddr, vkGetDeviceProcAddr, vkGetDeviceProcAddrUnsafe, vkGetDeviceProcAddrSafe, 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, 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(), VkFormatProperties2, VkFormatProperties2KHR, VkImageBlit, VkImageCopy, VkImageCreateInfo, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageDrmFormatModifierPropertiesEXT, VkImageFormatListCreateInfo, VkImageFormatListCreateInfoKHR, VkImageFormatProperties2, VkImageFormatProperties2KHR, VkImageMemoryRequirementsInfo2, VkImageMemoryRequirementsInfo2KHR, VkImagePlaneMemoryRequirementsInfo, VkImagePlaneMemoryRequirementsInfoKHR, VkImageResolve, VkImageSparseMemoryRequirementsInfo2, VkImageSparseMemoryRequirementsInfo2KHR, VkImageStencilUsageCreateInfo, VkImageStencilUsageCreateInfoEXT, VkImageSubresource, VkImageSubresourceLayers, VkImageSwapchainCreateInfoKHR, VkImageViewASTCDecodeModeEXT, VkImageViewAddressPropertiesNVX, VkImageViewCreateInfo, VkImageViewHandleInfoNVX, VkImageViewUsageCreateInfo, VkImageViewUsageCreateInfoKHR, VkMemoryAllocateFlagsInfo, VkMemoryAllocateFlagsInfoKHR, VkMemoryAllocateInfo, VkMemoryDedicatedAllocateInfo, VkMemoryDedicatedAllocateInfoKHR, VkMemoryDedicatedRequirements, VkMemoryDedicatedRequirementsKHR, VkMemoryFdPropertiesKHR, VkMemoryGetFdInfoKHR, VkMemoryHostPointerPropertiesEXT, VkMemoryOpaqueCaptureAddressAllocateInfo, VkMemoryOpaqueCaptureAddressAllocateInfoKHR, VkMemoryPriorityAllocateInfoEXT, VkMemoryRequirements, VkMemoryRequirements2, VkMemoryRequirements2KHR, VkPhysicalDevice16BitStorageFeatures, 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, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFeatures2KHR, VkPhysicalDeviceFloat16Int8FeaturesKHR, VkPhysicalDeviceFloatControlsProperties, VkPhysicalDeviceFloatControlsPropertiesKHR, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT, VkPhysicalDeviceFragmentDensityMap2PropertiesEXT, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentDensityMapPropertiesEXT, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceGroupProperties, VkPhysicalDeviceGroupPropertiesKHR, VkPhysicalDeviceHostQueryResetFeatures, VkPhysicalDeviceHostQueryResetFeaturesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceIDPropertiesKHR, VkPhysicalDeviceImageDrmFormatModifierInfoEXT, VkPhysicalDeviceImageFormatInfo2, VkPhysicalDeviceImageFormatInfo2KHR, VkPhysicalDeviceImageRobustnessFeaturesEXT, VkPhysicalDeviceImageViewImageFormatInfoEXT, VkPhysicalDeviceImagelessFramebufferFeatures, VkPhysicalDeviceImagelessFramebufferFeaturesKHR, VkPhysicalDeviceIndexTypeUint8FeaturesEXT, VkPhysicalDeviceInlineUniformBlockFeaturesEXT, VkPhysicalDeviceInlineUniformBlockPropertiesEXT, VkPhysicalDeviceLineRasterizationFeaturesEXT, VkPhysicalDeviceLineRasterizationPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMaintenance3PropertiesKHR, VkPhysicalDeviceMemoryBudgetPropertiesEXT, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMemoryProperties2, VkPhysicalDeviceMemoryProperties2KHR, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceMultiviewFeaturesKHR, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDeviceMultiviewPropertiesKHR, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePerformanceQueryFeaturesKHR, VkPhysicalDevicePerformanceQueryPropertiesKHR, VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, VkPhysicalDevicePointClippingProperties, VkPhysicalDevicePointClippingPropertiesKHR, VkPhysicalDevicePrivateDataFeaturesEXT, VkPhysicalDeviceProperties2, 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, VkPhysicalDeviceSubgroupProperties, 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, VkQueueFamilyCheckpointPropertiesNV, VkQueueFamilyProperties2, VkQueueFamilyProperties2KHR, -- ** Device commands VkDeviceCreateInfo, VkDeviceDiagnosticsConfigBitmaskNV(..), VkDeviceEventTypeEXT(..), VkDeviceGroupPresentModeBitmaskKHR(..), VkDeviceCreateFlagBits(..), VkDeviceDiagnosticsConfigFlagBitsNV(), VkDeviceDiagnosticsConfigFlagsNV(), VkDeviceGroupPresentModeFlagBitsKHR(), VkDeviceGroupPresentModeFlagsKHR(), VkDeviceQueueCreateBitmask(..), VkDeviceQueueCreateFlagBits(), VkDeviceQueueCreateFlags(), VkDeviceQueueCreateInfo, -- > ##include "vk_platform.h" VkCreateDevice, pattern VkCreateDevice, HS_vkCreateDevice, PFN_vkCreateDevice, vkCreateDevice, vkCreateDeviceUnsafe, vkCreateDeviceSafe, VkDestroyDevice, pattern VkDestroyDevice, HS_vkDestroyDevice, PFN_vkDestroyDevice, vkDestroyDevice, vkDestroyDeviceUnsafe, vkDestroyDeviceSafe, VkDeviceDiagnosticsConfigCreateInfoNV, VkDeviceEventInfoEXT, VkDeviceGroupBindSparseInfo, VkDeviceGroupBindSparseInfoKHR, VkDeviceGroupCommandBufferBeginInfo, VkDeviceGroupCommandBufferBeginInfoKHR, VkDeviceGroupDeviceCreateInfo, VkDeviceGroupDeviceCreateInfoKHR, VkDeviceGroupPresentCapabilitiesKHR, VkDeviceGroupPresentInfoKHR, VkDeviceGroupRenderPassBeginInfo, VkDeviceGroupRenderPassBeginInfoKHR, VkDeviceGroupSubmitInfo, VkDeviceGroupSubmitInfoKHR, VkDeviceGroupSwapchainCreateInfoKHR, VkDeviceMemoryOpaqueCaptureAddressInfo, VkDeviceMemoryOpaqueCaptureAddressInfoKHR, VkDeviceMemoryOverallocationCreateInfoAMD, VkDevicePrivateDataCreateInfoEXT, VkDeviceQueueGlobalPriorityCreateInfoEXT, VkDeviceQueueInfo2, -- ** Extension discovery commands VkExtensionProperties, -- > ##include "vk_platform.h" VkEnumerateInstanceExtensionProperties, pattern VkEnumerateInstanceExtensionProperties, HS_vkEnumerateInstanceExtensionProperties, PFN_vkEnumerateInstanceExtensionProperties, vkEnumerateInstanceExtensionProperties, vkEnumerateInstanceExtensionPropertiesUnsafe, vkEnumerateInstanceExtensionPropertiesSafe, VkEnumerateDeviceExtensionProperties, pattern VkEnumerateDeviceExtensionProperties, HS_vkEnumerateDeviceExtensionProperties, PFN_vkEnumerateDeviceExtensionProperties, vkEnumerateDeviceExtensionProperties, vkEnumerateDeviceExtensionPropertiesUnsafe, vkEnumerateDeviceExtensionPropertiesSafe, -- ** Layer discovery commands VkLayerProperties, -- > ##include "vk_platform.h" VkEnumerateInstanceLayerProperties, pattern VkEnumerateInstanceLayerProperties, HS_vkEnumerateInstanceLayerProperties, PFN_vkEnumerateInstanceLayerProperties, vkEnumerateInstanceLayerProperties, vkEnumerateInstanceLayerPropertiesUnsafe, vkEnumerateInstanceLayerPropertiesSafe, VkEnumerateDeviceLayerProperties, pattern VkEnumerateDeviceLayerProperties, HS_vkEnumerateDeviceLayerProperties, PFN_vkEnumerateDeviceLayerProperties, vkEnumerateDeviceLayerProperties, vkEnumerateDeviceLayerPropertiesUnsafe, vkEnumerateDeviceLayerPropertiesSafe, -- ** Queue commands VkSubmitInfo, -- > ##include "vk_platform.h" VkGetDeviceQueue, pattern VkGetDeviceQueue, HS_vkGetDeviceQueue, PFN_vkGetDeviceQueue, vkGetDeviceQueue, vkGetDeviceQueueUnsafe, vkGetDeviceQueueSafe, VkQueueSubmit, pattern VkQueueSubmit, HS_vkQueueSubmit, PFN_vkQueueSubmit, vkQueueSubmit, vkQueueSubmitUnsafe, vkQueueSubmitSafe, VkQueueWaitIdle, pattern VkQueueWaitIdle, HS_vkQueueWaitIdle, PFN_vkQueueWaitIdle, vkQueueWaitIdle, vkQueueWaitIdleUnsafe, vkQueueWaitIdleSafe, VkDeviceWaitIdle, pattern VkDeviceWaitIdle, HS_vkDeviceWaitIdle, PFN_vkDeviceWaitIdle, vkDeviceWaitIdle, vkDeviceWaitIdleUnsafe, vkDeviceWaitIdleSafe, -- ** Memory commands VkMappedMemoryRange, -- > ##include "vk_platform.h" VkAllocateMemory, pattern VkAllocateMemory, HS_vkAllocateMemory, PFN_vkAllocateMemory, vkAllocateMemory, vkAllocateMemoryUnsafe, vkAllocateMemorySafe, VkFreeMemory, pattern VkFreeMemory, HS_vkFreeMemory, PFN_vkFreeMemory, vkFreeMemory, vkFreeMemoryUnsafe, vkFreeMemorySafe, VkMapMemory, pattern VkMapMemory, HS_vkMapMemory, PFN_vkMapMemory, vkMapMemory, vkMapMemoryUnsafe, vkMapMemorySafe, VkUnmapMemory, pattern VkUnmapMemory, HS_vkUnmapMemory, PFN_vkUnmapMemory, vkUnmapMemory, vkUnmapMemoryUnsafe, vkUnmapMemorySafe, VkFlushMappedMemoryRanges, pattern VkFlushMappedMemoryRanges, HS_vkFlushMappedMemoryRanges, PFN_vkFlushMappedMemoryRanges, vkFlushMappedMemoryRanges, vkFlushMappedMemoryRangesUnsafe, vkFlushMappedMemoryRangesSafe, VkInvalidateMappedMemoryRanges, pattern VkInvalidateMappedMemoryRanges, HS_vkInvalidateMappedMemoryRanges, PFN_vkInvalidateMappedMemoryRanges, vkInvalidateMappedMemoryRanges, vkInvalidateMappedMemoryRangesUnsafe, vkInvalidateMappedMemoryRangesSafe, VkGetDeviceMemoryCommitment, pattern VkGetDeviceMemoryCommitment, HS_vkGetDeviceMemoryCommitment, PFN_vkGetDeviceMemoryCommitment, vkGetDeviceMemoryCommitment, vkGetDeviceMemoryCommitmentUnsafe, vkGetDeviceMemoryCommitmentSafe, -- > ##include "vk_platform.h" VkBindBufferMemory, pattern VkBindBufferMemory, HS_vkBindBufferMemory, PFN_vkBindBufferMemory, vkBindBufferMemory, vkBindBufferMemoryUnsafe, vkBindBufferMemorySafe, VkBindImageMemory, pattern VkBindImageMemory, HS_vkBindImageMemory, PFN_vkBindImageMemory, vkBindImageMemory, vkBindImageMemoryUnsafe, vkBindImageMemorySafe, VkGetBufferMemoryRequirements, pattern VkGetBufferMemoryRequirements, HS_vkGetBufferMemoryRequirements, PFN_vkGetBufferMemoryRequirements, vkGetBufferMemoryRequirements, vkGetBufferMemoryRequirementsUnsafe, vkGetBufferMemoryRequirementsSafe, VkGetImageMemoryRequirements, pattern VkGetImageMemoryRequirements, HS_vkGetImageMemoryRequirements, PFN_vkGetImageMemoryRequirements, vkGetImageMemoryRequirements, vkGetImageMemoryRequirementsUnsafe, vkGetImageMemoryRequirementsSafe, -- ** Sparse resource memory management API commands VkBindSparseInfo, VkSparseBufferMemoryBindInfo, VkSparseImageFormatBitmask(..), VkSparseMemoryBindBitmask(..), VkSparseImageFormatFlagBits(), VkSparseImageFormatFlags(), VkSparseMemoryBindFlagBits(), VkSparseMemoryBindFlags(), VkSparseImageFormatProperties, VkSparseImageMemoryBind, VkSparseImageMemoryBindInfo, VkSparseImageMemoryRequirements, VkSparseImageOpaqueMemoryBindInfo, VkSparseMemoryBind, -- > ##include "vk_platform.h" VkGetImageSparseMemoryRequirements, pattern VkGetImageSparseMemoryRequirements, HS_vkGetImageSparseMemoryRequirements, PFN_vkGetImageSparseMemoryRequirements, vkGetImageSparseMemoryRequirements, vkGetImageSparseMemoryRequirementsUnsafe, vkGetImageSparseMemoryRequirementsSafe, VkGetPhysicalDeviceSparseImageFormatProperties, pattern VkGetPhysicalDeviceSparseImageFormatProperties, HS_vkGetPhysicalDeviceSparseImageFormatProperties, PFN_vkGetPhysicalDeviceSparseImageFormatProperties, vkGetPhysicalDeviceSparseImageFormatProperties, vkGetPhysicalDeviceSparseImageFormatPropertiesUnsafe, vkGetPhysicalDeviceSparseImageFormatPropertiesSafe, VkQueueBindSparse, pattern VkQueueBindSparse, HS_vkQueueBindSparse, PFN_vkQueueBindSparse, vkQueueBindSparse, vkQueueBindSparseUnsafe, vkQueueBindSparseSafe, {-# LINE 562 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} VkBindAccelerationStructureMemoryInfoNV, VkWriteDescriptorSetAccelerationStructureNV, {-# LINE 565 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} VkBindBufferMemoryDeviceGroupInfo, VkBindBufferMemoryDeviceGroupInfoKHR, VkBindBufferMemoryInfo, VkBindBufferMemoryInfoKHR, VkBindImageMemoryDeviceGroupInfo, VkBindImageMemoryDeviceGroupInfoKHR, VkBindImageMemoryInfo, VkBindImageMemoryInfoKHR, VkBindImageMemorySwapchainInfoKHR, VkBindImagePlaneMemoryInfo, VkBindImagePlaneMemoryInfoKHR, VkBindIndexBufferIndirectCommandNV, VkBindShaderGroupIndirectCommandNV, VkBindVertexBufferIndirectCommandNV, VkSparseImageFormatProperties2, VkSparseImageFormatProperties2KHR, VkSparseImageMemoryRequirements2, VkSparseImageMemoryRequirements2KHR, -- ** Fence commands VkFenceCreateBitmask(..), VkFenceImportBitmask(..), VkFenceCreateFlagBits(), VkFenceCreateFlags(), VkFenceImportFlagBits(), VkFenceImportFlagBitsKHR(..), VkFenceImportFlags(), VkFenceCreateInfo, -- > ##include "vk_platform.h" VkCreateFence, pattern VkCreateFence, HS_vkCreateFence, PFN_vkCreateFence, vkCreateFence, vkCreateFenceUnsafe, vkCreateFenceSafe, VkDestroyFence, pattern VkDestroyFence, HS_vkDestroyFence, PFN_vkDestroyFence, vkDestroyFence, vkDestroyFenceUnsafe, vkDestroyFenceSafe, VkResetFences, pattern VkResetFences, HS_vkResetFences, PFN_vkResetFences, vkResetFences, vkResetFencesUnsafe, vkResetFencesSafe, VkGetFenceStatus, pattern VkGetFenceStatus, HS_vkGetFenceStatus, PFN_vkGetFenceStatus, vkGetFenceStatus, vkGetFenceStatusUnsafe, vkGetFenceStatusSafe, VkWaitForFences, pattern VkWaitForFences, HS_vkWaitForFences, PFN_vkWaitForFences, vkWaitForFences, vkWaitForFencesUnsafe, vkWaitForFencesSafe, VkFenceGetFdInfoKHR, -- ** Queue semaphore commands VkSemaphoreCreateInfo, -- > ##include "vk_platform.h" VkCreateSemaphore, pattern VkCreateSemaphore, HS_vkCreateSemaphore, PFN_vkCreateSemaphore, vkCreateSemaphore, vkCreateSemaphoreUnsafe, vkCreateSemaphoreSafe, VkDestroySemaphore, pattern VkDestroySemaphore, HS_vkDestroySemaphore, PFN_vkDestroySemaphore, vkDestroySemaphore, vkDestroySemaphoreUnsafe, vkDestroySemaphoreSafe, VkSemaphoreGetFdInfoKHR, VkSemaphoreSignalInfo, VkSemaphoreSignalInfoKHR, VkSemaphoreTypeCreateInfo, VkSemaphoreTypeCreateInfoKHR, VkSemaphoreWaitInfo, VkSemaphoreWaitInfoKHR, -- ** Event commands VkEventCreateInfo, -- > ##include "vk_platform.h" VkCreateEvent, pattern VkCreateEvent, HS_vkCreateEvent, PFN_vkCreateEvent, vkCreateEvent, vkCreateEventUnsafe, vkCreateEventSafe, VkDestroyEvent, pattern VkDestroyEvent, HS_vkDestroyEvent, PFN_vkDestroyEvent, vkDestroyEvent, vkDestroyEventUnsafe, vkDestroyEventSafe, VkGetEventStatus, pattern VkGetEventStatus, HS_vkGetEventStatus, PFN_vkGetEventStatus, vkGetEventStatus, vkGetEventStatusUnsafe, vkGetEventStatusSafe, VkSetEvent, pattern VkSetEvent, HS_vkSetEvent, PFN_vkSetEvent, vkSetEvent, vkSetEventUnsafe, vkSetEventSafe, VkResetEvent, pattern VkResetEvent, HS_vkResetEvent, PFN_vkResetEvent, vkResetEvent, vkResetEventUnsafe, vkResetEventSafe, -- ** Query commands VkQueryControlBitmask(..), VkQueryPipelineStatisticBitmask(..), VkQueryPoolSamplingModeINTEL(..), VkQueryResultBitmask(..), VkQueryType(..), VkQueryControlFlagBits(), VkQueryControlFlags(), VkQueryPipelineStatisticFlagBits(), VkQueryPipelineStatisticFlags(), VkQueryPoolCreateFlagBits(..), VkQueryResultFlagBits(), VkQueryResultFlags(), VkQueryPoolCreateInfo, -- > ##include "vk_platform.h" VkCreateQueryPool, pattern VkCreateQueryPool, HS_vkCreateQueryPool, PFN_vkCreateQueryPool, vkCreateQueryPool, vkCreateQueryPoolUnsafe, vkCreateQueryPoolSafe, VkDestroyQueryPool, pattern VkDestroyQueryPool, HS_vkDestroyQueryPool, PFN_vkDestroyQueryPool, vkDestroyQueryPool, vkDestroyQueryPoolUnsafe, vkDestroyQueryPoolSafe, VkGetQueryPoolResults, pattern VkGetQueryPoolResults, HS_vkGetQueryPoolResults, PFN_vkGetQueryPoolResults, vkGetQueryPoolResults, vkGetQueryPoolResultsUnsafe, vkGetQueryPoolResultsSafe, VkQueryPoolCreateInfoINTEL, VkQueryPoolPerformanceCreateInfoKHR, VkQueryPoolPerformanceQueryCreateInfoINTEL, -- ** Buffer commands VkBufferCreateBitmask(..), VkBufferUsageBitmask(..), VkBufferCreateFlagBits(), VkBufferCreateFlags(), VkBufferUsageFlagBits(), VkBufferUsageFlags(), VkBufferCreateInfo, VkSharingMode(..), -- > ##include "vk_platform.h" VkCreateBuffer, pattern VkCreateBuffer, HS_vkCreateBuffer, PFN_vkCreateBuffer, vkCreateBuffer, vkCreateBufferUnsafe, vkCreateBufferSafe, VkDestroyBuffer, pattern VkDestroyBuffer, HS_vkDestroyBuffer, PFN_vkDestroyBuffer, vkDestroyBuffer, vkDestroyBufferUnsafe, vkDestroyBufferSafe, VkBufferCopy, VkBufferDeviceAddressCreateInfoEXT, VkBufferDeviceAddressInfo, VkBufferDeviceAddressInfoEXT, VkBufferDeviceAddressInfoKHR, VkBufferImageCopy, VkBufferMemoryRequirementsInfo2, VkBufferMemoryRequirementsInfo2KHR, VkBufferOpaqueCaptureAddressCreateInfo, VkBufferOpaqueCaptureAddressCreateInfoKHR, VkBufferViewCreateInfo, -- > ##include "vk_platform.h" VkCreateBufferView, pattern VkCreateBufferView, HS_vkCreateBufferView, PFN_vkCreateBufferView, vkCreateBufferView, vkCreateBufferViewUnsafe, vkCreateBufferViewSafe, VkDestroyBufferView, pattern VkDestroyBufferView, HS_vkDestroyBufferView, PFN_vkDestroyBufferView, vkDestroyBufferView, vkDestroyBufferViewUnsafe, vkDestroyBufferViewSafe, VkSubresourceLayout, -- > ##include "vk_platform.h" VkCreateImage, pattern VkCreateImage, HS_vkCreateImage, PFN_vkCreateImage, vkCreateImage, vkCreateImageUnsafe, vkCreateImageSafe, VkDestroyImage, pattern VkDestroyImage, HS_vkDestroyImage, PFN_vkDestroyImage, vkDestroyImage, vkDestroyImageUnsafe, vkDestroyImageSafe, VkGetImageSubresourceLayout, pattern VkGetImageSubresourceLayout, HS_vkGetImageSubresourceLayout, PFN_vkGetImageSubresourceLayout, vkGetImageSubresourceLayout, vkGetImageSubresourceLayoutUnsafe, vkGetImageSubresourceLayoutSafe, -- ** Image view commands VkComponentMapping, VkComponentSwizzle(..), VkComponentTypeNV(..), -- > ##include "vk_platform.h" VkCreateImageView, pattern VkCreateImageView, HS_vkCreateImageView, PFN_vkCreateImageView, vkCreateImageView, vkCreateImageViewUnsafe, vkCreateImageViewSafe, VkDestroyImageView, pattern VkDestroyImageView, HS_vkDestroyImageView, PFN_vkDestroyImageView, vkDestroyImageView, vkDestroyImageViewUnsafe, vkDestroyImageViewSafe, -- ** Shader commands VkShaderFloatControlsIndependence(..), VkShaderInfoTypeAMD(..), VkShaderStageBitmask(..), VkShaderCorePropertiesBitmaskAMD(..), VkShaderCorePropertiesFlagBitsAMD(), VkShaderCorePropertiesFlagsAMD(), VkShaderFloatControlsIndependenceKHR(..), VkShaderModuleCreateBitmask(..), VkShaderModuleCreateFlagBits(), VkShaderModuleCreateFlags(), VkShaderStageFlagBits(), VkShaderStageFlags(), VkShaderModuleCreateInfo, -- > ##include "vk_platform.h" VkCreateShaderModule, pattern VkCreateShaderModule, HS_vkCreateShaderModule, PFN_vkCreateShaderModule, vkCreateShaderModule, vkCreateShaderModuleUnsafe, vkCreateShaderModuleSafe, VkDestroyShaderModule, pattern VkDestroyShaderModule, HS_vkDestroyShaderModule, PFN_vkDestroyShaderModule, vkDestroyShaderModule, vkDestroyShaderModuleUnsafe, vkDestroyShaderModuleSafe, VkShaderModuleValidationCacheCreateInfoEXT, VkShaderResourceUsageAMD, VkShaderStatisticsInfoAMD, -- ** Pipeline Cache commands VkPipelineCacheCreateInfo, -- > ##include "vk_platform.h" VkCreatePipelineCache, pattern VkCreatePipelineCache, HS_vkCreatePipelineCache, PFN_vkCreatePipelineCache, vkCreatePipelineCache, vkCreatePipelineCacheUnsafe, vkCreatePipelineCacheSafe, VkDestroyPipelineCache, pattern VkDestroyPipelineCache, HS_vkDestroyPipelineCache, PFN_vkDestroyPipelineCache, vkDestroyPipelineCache, vkDestroyPipelineCacheUnsafe, vkDestroyPipelineCacheSafe, VkGetPipelineCacheData, pattern VkGetPipelineCacheData, HS_vkGetPipelineCacheData, PFN_vkGetPipelineCacheData, vkGetPipelineCacheData, vkGetPipelineCacheDataUnsafe, vkGetPipelineCacheDataSafe, VkMergePipelineCaches, pattern VkMergePipelineCaches, HS_vkMergePipelineCaches, PFN_vkMergePipelineCaches, vkMergePipelineCaches, vkMergePipelineCachesUnsafe, vkMergePipelineCachesSafe, VkGraphicsPipelineCreateInfo, VkPipelineColorBlendAdvancedStateCreateInfoEXT, VkPipelineColorBlendAttachmentState, VkPipelineColorBlendStateCreateInfo, VkPipelineCompilerControlCreateInfoAMD, VkPipelineCoverageModulationStateCreateInfoNV, VkPipelineCoverageReductionStateCreateInfoNV, VkPipelineCoverageToColorStateCreateInfoNV, VkPipelineCreationFeedbackCreateInfoEXT, VkPipelineCreationFeedbackEXT, VkPipelineDepthStencilStateCreateInfo, VkPipelineDiscardRectangleStateCreateInfoEXT, VkPipelineDynamicStateCreateInfo, VkPipelineExecutableInfoKHR, VkPipelineExecutableInternalRepresentationKHR, VkPipelineExecutablePropertiesKHR, VkPipelineExecutableStatisticKHR, VkPipelineExecutableStatisticValueKHR, VkPipelineInfoKHR, VkPipelineInputAssemblyStateCreateInfo, VkPipelineLayoutCreateInfo, VkPipelineMultisampleStateCreateInfo, VkPipelineRasterizationConservativeStateCreateInfoEXT, VkPipelineRasterizationDepthClipStateCreateInfoEXT, VkPipelineRasterizationLineStateCreateInfoEXT, VkPipelineRasterizationStateCreateInfo, VkPipelineRasterizationStateRasterizationOrderAMD, VkPipelineRasterizationStateStreamCreateInfoEXT, VkPipelineRepresentativeFragmentTestStateCreateInfoNV, VkPipelineSampleLocationsStateCreateInfoEXT, VkPipelineShaderStageCreateInfo, VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT, VkPipelineTessellationDomainOriginStateCreateInfo, VkPipelineTessellationDomainOriginStateCreateInfoKHR, VkPipelineTessellationStateCreateInfo, VkPipelineVertexInputDivisorStateCreateInfoEXT, VkPipelineVertexInputStateCreateInfo, VkPipelineViewportCoarseSampleOrderStateCreateInfoNV, VkPipelineViewportExclusiveScissorStateCreateInfoNV, VkPipelineViewportShadingRateImageStateCreateInfoNV, VkPipelineViewportStateCreateInfo, VkPipelineViewportSwizzleStateCreateInfoNV, VkPipelineViewportWScalingStateCreateInfoNV, -- ** Pipeline commands VkBlendFactor(..), VkBlendOp(..), VkBlendOverlapEXT(..), pattern VK_COLORSPACE_SRGB_NONLINEAR_KHR, VkColorComponentBitmask(..), VkColorSpaceKHR(..), VkColorComponentFlagBits(), VkColorComponentFlags(), VkCompareOp(..), VkComputePipelineCreateInfo, VkCullModeBitmask(..), VkCullModeFlagBits(), VkCullModeFlags(), VkDynamicState(..), VkFrontFace(..), VkLogicOp(..), VkPolygonMode(..), VkPrimitiveTopology(..), VkSpecializationInfo, VkSpecializationMapEntry, VkStencilFaceBitmask(..), VkStencilOp(..), VkStencilFaceFlagBits(), VkStencilFaceFlags(), VkStencilOpState, VkVertexInputAttributeDescription, VkVertexInputBindingDescription, VkVertexInputRate(..), VkViewport, -- > ##include "vk_platform.h" VkCreateGraphicsPipelines, pattern VkCreateGraphicsPipelines, HS_vkCreateGraphicsPipelines, PFN_vkCreateGraphicsPipelines, vkCreateGraphicsPipelines, vkCreateGraphicsPipelinesUnsafe, vkCreateGraphicsPipelinesSafe, VkCreateComputePipelines, pattern VkCreateComputePipelines, HS_vkCreateComputePipelines, PFN_vkCreateComputePipelines, vkCreateComputePipelines, vkCreateComputePipelinesUnsafe, vkCreateComputePipelinesSafe, VkDestroyPipeline, pattern VkDestroyPipeline, HS_vkDestroyPipeline, PFN_vkDestroyPipeline, vkDestroyPipeline, vkDestroyPipelineUnsafe, vkDestroyPipelineSafe, VkRectLayerKHR, VkVertexInputBindingDivisorDescriptionEXT, VkViewportSwizzleNV, VkViewportWScalingNV, VkPushConstantRange, -- > ##include "vk_platform.h" VkCreatePipelineLayout, pattern VkCreatePipelineLayout, HS_vkCreatePipelineLayout, PFN_vkCreatePipelineLayout, vkCreatePipelineLayout, vkCreatePipelineLayoutUnsafe, vkCreatePipelineLayoutSafe, VkDestroyPipelineLayout, pattern VkDestroyPipelineLayout, HS_vkDestroyPipelineLayout, PFN_vkDestroyPipelineLayout, vkDestroyPipelineLayout, vkDestroyPipelineLayoutUnsafe, vkDestroyPipelineLayoutSafe, -- ** Sampler commands VkBorderColor(..), VkFilter(..), VkSamplerAddressMode(..), VkSamplerMipmapMode(..), VkSamplerReductionMode(..), VkSamplerYcbcrModelConversion(..), VkSamplerYcbcrRange(..), VkSamplerCreateBitmask(..), VkSamplerCreateFlagBits(), VkSamplerCreateFlags(), VkSamplerReductionModeEXT(..), VkSamplerYcbcrModelConversionKHR(..), VkSamplerYcbcrRangeKHR(..), VkSamplerCreateInfo, -- > ##include "vk_platform.h" VkCreateSampler, pattern VkCreateSampler, HS_vkCreateSampler, PFN_vkCreateSampler, vkCreateSampler, vkCreateSamplerUnsafe, vkCreateSamplerSafe, VkDestroySampler, pattern VkDestroySampler, HS_vkDestroySampler, PFN_vkDestroySampler, vkDestroySampler, vkDestroySamplerUnsafe, vkDestroySamplerSafe, VkSamplerCustomBorderColorCreateInfoEXT, VkSamplerReductionModeCreateInfo, VkSamplerReductionModeCreateInfoEXT, VkSamplerYcbcrConversionCreateInfo, VkSamplerYcbcrConversionCreateInfoKHR, VkSamplerYcbcrConversionImageFormatProperties, VkSamplerYcbcrConversionImageFormatPropertiesKHR, VkSamplerYcbcrConversionInfo, VkSamplerYcbcrConversionInfoKHR, -- ** Descriptor set commands VkCopyDescriptorSet, VkDescriptorBufferInfo, VkDescriptorImageInfo, VkDescriptorBindingBitmask(..), VkDescriptorPoolCreateBitmask(..), VkDescriptorType(..), VkDescriptorUpdateTemplateType(..), VkDescriptorBindingFlagBits(), VkDescriptorBindingFlagBitsEXT(..), VkDescriptorBindingFlags(), VkDescriptorPoolCreateFlagBits(), VkDescriptorPoolCreateFlags(), VkDescriptorSetLayoutCreateBitmask(..), VkDescriptorSetLayoutCreateFlagBits(), VkDescriptorSetLayoutCreateFlags(), VkDescriptorUpdateTemplateTypeKHR(..), VkDescriptorPoolCreateInfo, VkDescriptorPoolSize, VkDescriptorSetAllocateInfo, VkDescriptorSetLayoutBinding, VkDescriptorSetLayoutCreateInfo, VkWriteDescriptorSet, -- > ##include "vk_platform.h" VkCreateDescriptorSetLayout, pattern VkCreateDescriptorSetLayout, HS_vkCreateDescriptorSetLayout, PFN_vkCreateDescriptorSetLayout, vkCreateDescriptorSetLayout, vkCreateDescriptorSetLayoutUnsafe, vkCreateDescriptorSetLayoutSafe, VkDestroyDescriptorSetLayout, pattern VkDestroyDescriptorSetLayout, HS_vkDestroyDescriptorSetLayout, PFN_vkDestroyDescriptorSetLayout, vkDestroyDescriptorSetLayout, vkDestroyDescriptorSetLayoutUnsafe, vkDestroyDescriptorSetLayoutSafe, VkCreateDescriptorPool, pattern VkCreateDescriptorPool, HS_vkCreateDescriptorPool, PFN_vkCreateDescriptorPool, vkCreateDescriptorPool, vkCreateDescriptorPoolUnsafe, vkCreateDescriptorPoolSafe, VkDestroyDescriptorPool, pattern VkDestroyDescriptorPool, HS_vkDestroyDescriptorPool, PFN_vkDestroyDescriptorPool, vkDestroyDescriptorPool, vkDestroyDescriptorPoolUnsafe, vkDestroyDescriptorPoolSafe, VkResetDescriptorPool, pattern VkResetDescriptorPool, HS_vkResetDescriptorPool, PFN_vkResetDescriptorPool, vkResetDescriptorPool, vkResetDescriptorPoolUnsafe, vkResetDescriptorPoolSafe, VkAllocateDescriptorSets, pattern VkAllocateDescriptorSets, HS_vkAllocateDescriptorSets, PFN_vkAllocateDescriptorSets, vkAllocateDescriptorSets, vkAllocateDescriptorSetsUnsafe, vkAllocateDescriptorSetsSafe, VkFreeDescriptorSets, pattern VkFreeDescriptorSets, HS_vkFreeDescriptorSets, PFN_vkFreeDescriptorSets, vkFreeDescriptorSets, vkFreeDescriptorSetsUnsafe, vkFreeDescriptorSetsSafe, VkUpdateDescriptorSets, pattern VkUpdateDescriptorSets, HS_vkUpdateDescriptorSets, PFN_vkUpdateDescriptorSets, vkUpdateDescriptorSets, vkUpdateDescriptorSetsUnsafe, vkUpdateDescriptorSetsSafe, VkDescriptorPoolInlineUniformBlockCreateInfoEXT, VkDescriptorSetLayoutBindingFlagsCreateInfo, VkDescriptorSetLayoutBindingFlagsCreateInfoEXT, VkDescriptorSetLayoutSupport, VkDescriptorSetLayoutSupportKHR, VkDescriptorSetVariableDescriptorCountAllocateInfo, VkDescriptorSetVariableDescriptorCountAllocateInfoEXT, VkDescriptorSetVariableDescriptorCountLayoutSupport, VkDescriptorSetVariableDescriptorCountLayoutSupportEXT, VkDescriptorUpdateTemplateCreateInfo, VkDescriptorUpdateTemplateCreateInfoKHR, VkDescriptorUpdateTemplateEntry, VkDescriptorUpdateTemplateEntryKHR, VkWriteDescriptorSetInlineUniformBlockEXT, -- ** Pass commands VkAttachmentDescription, VkAttachmentDescriptionBitmask(..), VkAttachmentLoadOp(..), VkAttachmentStoreOp(..), VkAttachmentDescriptionFlagBits(), VkAttachmentDescriptionFlags(), VkAttachmentReference, VkDependencyBitmask(..), VkDependencyFlagBits(), VkDependencyFlags(), VkFramebufferCreateBitmask(..), VkFramebufferCreateFlagBits(), VkFramebufferCreateFlags(), VkFramebufferCreateInfo, VkRenderPassCreateBitmask(..), VkRenderPassCreateFlagBits(), VkRenderPassCreateFlags(), VkRenderPassCreateInfo, VkSubpassDependency, VkSubpassDescription, VkSubpassContents(..), VkSubpassDescriptionBitmask(..), VkSubpassDescriptionFlagBits(), VkSubpassDescriptionFlags(), -- > ##include "vk_platform.h" VkCreateFramebuffer, pattern VkCreateFramebuffer, HS_vkCreateFramebuffer, PFN_vkCreateFramebuffer, vkCreateFramebuffer, vkCreateFramebufferUnsafe, vkCreateFramebufferSafe, VkDestroyFramebuffer, pattern VkDestroyFramebuffer, HS_vkDestroyFramebuffer, PFN_vkDestroyFramebuffer, vkDestroyFramebuffer, vkDestroyFramebufferUnsafe, vkDestroyFramebufferSafe, VkCreateRenderPass, pattern VkCreateRenderPass, HS_vkCreateRenderPass, PFN_vkCreateRenderPass, vkCreateRenderPass, vkCreateRenderPassUnsafe, vkCreateRenderPassSafe, VkDestroyRenderPass, pattern VkDestroyRenderPass, HS_vkDestroyRenderPass, PFN_vkDestroyRenderPass, vkDestroyRenderPass, vkDestroyRenderPassUnsafe, vkDestroyRenderPassSafe, VkGetRenderAreaGranularity, pattern VkGetRenderAreaGranularity, HS_vkGetRenderAreaGranularity, PFN_vkGetRenderAreaGranularity, vkGetRenderAreaGranularity, vkGetRenderAreaGranularityUnsafe, vkGetRenderAreaGranularitySafe, VkAttachmentDescription2, VkAttachmentDescription2KHR, VkAttachmentDescriptionStencilLayout, VkAttachmentDescriptionStencilLayoutKHR, VkAttachmentReference2, VkAttachmentReference2KHR, VkAttachmentReferenceStencilLayout, VkAttachmentReferenceStencilLayoutKHR, VkAttachmentSampleLocationsEXT, VkFramebufferAttachmentImageInfo, VkFramebufferAttachmentImageInfoKHR, VkFramebufferAttachmentsCreateInfo, VkFramebufferAttachmentsCreateInfoKHR, VkFramebufferMixedSamplesCombinationNV, VkRenderPassAttachmentBeginInfo, VkRenderPassAttachmentBeginInfoKHR, VkRenderPassBeginInfo, VkRenderPassCreateInfo2, VkRenderPassCreateInfo2KHR, VkRenderPassFragmentDensityMapCreateInfoEXT, VkRenderPassInputAttachmentAspectCreateInfo, VkRenderPassInputAttachmentAspectCreateInfoKHR, VkRenderPassMultiviewCreateInfo, VkRenderPassMultiviewCreateInfoKHR, VkRenderPassSampleLocationsBeginInfoEXT, VkRenderPassTransformBeginInfoQCOM, VkSubpassBeginInfo, VkSubpassBeginInfoKHR, VkSubpassDependency2, VkSubpassDependency2KHR, VkSubpassDescription2, VkSubpassDescription2KHR, VkSubpassDescriptionDepthStencilResolve, VkSubpassDescriptionDepthStencilResolveKHR, VkSubpassEndInfo, VkSubpassEndInfoKHR, VkSubpassSampleLocationsEXT, -- ** Command pool commands VkCommandBufferLevel(..), VkCommandBufferResetBitmask(..), VkCommandBufferUsageBitmask(..), VkCommandPoolCreateBitmask(..), VkCommandPoolResetBitmask(..), VkCommandBufferResetFlagBits(), VkCommandBufferResetFlags(), VkCommandBufferUsageFlagBits(), VkCommandBufferUsageFlags(), VkCommandPoolCreateFlagBits(), VkCommandPoolCreateFlags(), VkCommandPoolResetFlagBits(), VkCommandPoolResetFlags(), VkCommandPoolCreateInfo, -- > ##include "vk_platform.h" VkCreateCommandPool, pattern VkCreateCommandPool, HS_vkCreateCommandPool, PFN_vkCreateCommandPool, vkCreateCommandPool, vkCreateCommandPoolUnsafe, vkCreateCommandPoolSafe, VkDestroyCommandPool, pattern VkDestroyCommandPool, HS_vkDestroyCommandPool, PFN_vkDestroyCommandPool, vkDestroyCommandPool, vkDestroyCommandPoolUnsafe, vkDestroyCommandPoolSafe, VkResetCommandPool, pattern VkResetCommandPool, HS_vkResetCommandPool, PFN_vkResetCommandPool, vkResetCommandPool, vkResetCommandPoolUnsafe, vkResetCommandPoolSafe, VkCommandBufferAllocateInfo, VkCommandBufferBeginInfo, VkCommandBufferInheritanceConditionalRenderingInfoEXT, VkCommandBufferInheritanceInfo, VkCommandBufferInheritanceRenderPassTransformInfoQCOM, -- > ##include "vk_platform.h" VkAllocateCommandBuffers, pattern VkAllocateCommandBuffers, HS_vkAllocateCommandBuffers, PFN_vkAllocateCommandBuffers, vkAllocateCommandBuffers, vkAllocateCommandBuffersUnsafe, vkAllocateCommandBuffersSafe, VkFreeCommandBuffers, pattern VkFreeCommandBuffers, HS_vkFreeCommandBuffers, PFN_vkFreeCommandBuffers, vkFreeCommandBuffers, vkFreeCommandBuffersUnsafe, vkFreeCommandBuffersSafe, VkBeginCommandBuffer, pattern VkBeginCommandBuffer, HS_vkBeginCommandBuffer, PFN_vkBeginCommandBuffer, vkBeginCommandBuffer, vkBeginCommandBufferUnsafe, vkBeginCommandBufferSafe, VkEndCommandBuffer, pattern VkEndCommandBuffer, HS_vkEndCommandBuffer, PFN_vkEndCommandBuffer, vkEndCommandBuffer, vkEndCommandBufferUnsafe, vkEndCommandBufferSafe, VkResetCommandBuffer, pattern VkResetCommandBuffer, HS_vkResetCommandBuffer, PFN_vkResetCommandBuffer, vkResetCommandBuffer, vkResetCommandBufferUnsafe, vkResetCommandBufferSafe, VkClearAttachment, VkClearColorValue, VkClearDepthStencilValue, VkClearRect, VkClearValue, VkIndexType(..), -- > ##include "vk_platform.h" VkCmdBindPipeline, pattern VkCmdBindPipeline, HS_vkCmdBindPipeline, PFN_vkCmdBindPipeline, vkCmdBindPipeline, vkCmdBindPipelineUnsafe, vkCmdBindPipelineSafe, VkCmdSetViewport, pattern VkCmdSetViewport, HS_vkCmdSetViewport, PFN_vkCmdSetViewport, vkCmdSetViewport, vkCmdSetViewportUnsafe, vkCmdSetViewportSafe, VkCmdSetScissor, pattern VkCmdSetScissor, HS_vkCmdSetScissor, PFN_vkCmdSetScissor, vkCmdSetScissor, vkCmdSetScissorUnsafe, vkCmdSetScissorSafe, VkCmdSetLineWidth, pattern VkCmdSetLineWidth, HS_vkCmdSetLineWidth, PFN_vkCmdSetLineWidth, vkCmdSetLineWidth, vkCmdSetLineWidthUnsafe, vkCmdSetLineWidthSafe, VkCmdSetDepthBias, pattern VkCmdSetDepthBias, HS_vkCmdSetDepthBias, PFN_vkCmdSetDepthBias, vkCmdSetDepthBias, vkCmdSetDepthBiasUnsafe, vkCmdSetDepthBiasSafe, VkCmdSetBlendConstants, pattern VkCmdSetBlendConstants, HS_vkCmdSetBlendConstants, PFN_vkCmdSetBlendConstants, vkCmdSetBlendConstants, vkCmdSetBlendConstantsUnsafe, vkCmdSetBlendConstantsSafe, VkCmdSetDepthBounds, pattern VkCmdSetDepthBounds, HS_vkCmdSetDepthBounds, PFN_vkCmdSetDepthBounds, vkCmdSetDepthBounds, vkCmdSetDepthBoundsUnsafe, vkCmdSetDepthBoundsSafe, VkCmdSetStencilCompareMask, pattern VkCmdSetStencilCompareMask, HS_vkCmdSetStencilCompareMask, PFN_vkCmdSetStencilCompareMask, vkCmdSetStencilCompareMask, vkCmdSetStencilCompareMaskUnsafe, vkCmdSetStencilCompareMaskSafe, VkCmdSetStencilWriteMask, pattern VkCmdSetStencilWriteMask, HS_vkCmdSetStencilWriteMask, PFN_vkCmdSetStencilWriteMask, vkCmdSetStencilWriteMask, vkCmdSetStencilWriteMaskUnsafe, vkCmdSetStencilWriteMaskSafe, VkCmdSetStencilReference, pattern VkCmdSetStencilReference, HS_vkCmdSetStencilReference, PFN_vkCmdSetStencilReference, vkCmdSetStencilReference, vkCmdSetStencilReferenceUnsafe, vkCmdSetStencilReferenceSafe, VkCmdBindDescriptorSets, pattern VkCmdBindDescriptorSets, HS_vkCmdBindDescriptorSets, PFN_vkCmdBindDescriptorSets, vkCmdBindDescriptorSets, vkCmdBindDescriptorSetsUnsafe, vkCmdBindDescriptorSetsSafe, VkCmdBindIndexBuffer, pattern VkCmdBindIndexBuffer, HS_vkCmdBindIndexBuffer, PFN_vkCmdBindIndexBuffer, vkCmdBindIndexBuffer, vkCmdBindIndexBufferUnsafe, vkCmdBindIndexBufferSafe, VkCmdBindVertexBuffers, pattern VkCmdBindVertexBuffers, HS_vkCmdBindVertexBuffers, PFN_vkCmdBindVertexBuffers, vkCmdBindVertexBuffers, vkCmdBindVertexBuffersUnsafe, vkCmdBindVertexBuffersSafe, VkCmdDraw, pattern VkCmdDraw, HS_vkCmdDraw, PFN_vkCmdDraw, vkCmdDraw, vkCmdDrawUnsafe, vkCmdDrawSafe, VkCmdDrawIndexed, pattern VkCmdDrawIndexed, HS_vkCmdDrawIndexed, PFN_vkCmdDrawIndexed, vkCmdDrawIndexed, vkCmdDrawIndexedUnsafe, vkCmdDrawIndexedSafe, VkCmdDrawIndirect, pattern VkCmdDrawIndirect, HS_vkCmdDrawIndirect, PFN_vkCmdDrawIndirect, vkCmdDrawIndirect, vkCmdDrawIndirectUnsafe, vkCmdDrawIndirectSafe, VkCmdDrawIndexedIndirect, pattern VkCmdDrawIndexedIndirect, HS_vkCmdDrawIndexedIndirect, PFN_vkCmdDrawIndexedIndirect, vkCmdDrawIndexedIndirect, vkCmdDrawIndexedIndirectUnsafe, vkCmdDrawIndexedIndirectSafe, VkCmdDispatch, pattern VkCmdDispatch, HS_vkCmdDispatch, PFN_vkCmdDispatch, vkCmdDispatch, vkCmdDispatchUnsafe, vkCmdDispatchSafe, VkCmdDispatchIndirect, pattern VkCmdDispatchIndirect, HS_vkCmdDispatchIndirect, PFN_vkCmdDispatchIndirect, vkCmdDispatchIndirect, vkCmdDispatchIndirectUnsafe, vkCmdDispatchIndirectSafe, VkCmdCopyBuffer, pattern VkCmdCopyBuffer, HS_vkCmdCopyBuffer, PFN_vkCmdCopyBuffer, vkCmdCopyBuffer, vkCmdCopyBufferUnsafe, vkCmdCopyBufferSafe, VkCmdCopyImage, pattern VkCmdCopyImage, HS_vkCmdCopyImage, PFN_vkCmdCopyImage, vkCmdCopyImage, vkCmdCopyImageUnsafe, vkCmdCopyImageSafe, VkCmdBlitImage, pattern VkCmdBlitImage, HS_vkCmdBlitImage, PFN_vkCmdBlitImage, vkCmdBlitImage, vkCmdBlitImageUnsafe, vkCmdBlitImageSafe, VkCmdCopyBufferToImage, pattern VkCmdCopyBufferToImage, HS_vkCmdCopyBufferToImage, PFN_vkCmdCopyBufferToImage, vkCmdCopyBufferToImage, vkCmdCopyBufferToImageUnsafe, vkCmdCopyBufferToImageSafe, VkCmdCopyImageToBuffer, pattern VkCmdCopyImageToBuffer, HS_vkCmdCopyImageToBuffer, PFN_vkCmdCopyImageToBuffer, vkCmdCopyImageToBuffer, vkCmdCopyImageToBufferUnsafe, vkCmdCopyImageToBufferSafe, VkCmdUpdateBuffer, pattern VkCmdUpdateBuffer, HS_vkCmdUpdateBuffer, PFN_vkCmdUpdateBuffer, vkCmdUpdateBuffer, vkCmdUpdateBufferUnsafe, vkCmdUpdateBufferSafe, VkCmdFillBuffer, pattern VkCmdFillBuffer, HS_vkCmdFillBuffer, PFN_vkCmdFillBuffer, vkCmdFillBuffer, vkCmdFillBufferUnsafe, vkCmdFillBufferSafe, VkCmdClearColorImage, pattern VkCmdClearColorImage, HS_vkCmdClearColorImage, PFN_vkCmdClearColorImage, vkCmdClearColorImage, vkCmdClearColorImageUnsafe, vkCmdClearColorImageSafe, VkCmdClearDepthStencilImage, pattern VkCmdClearDepthStencilImage, HS_vkCmdClearDepthStencilImage, PFN_vkCmdClearDepthStencilImage, vkCmdClearDepthStencilImage, vkCmdClearDepthStencilImageUnsafe, vkCmdClearDepthStencilImageSafe, VkCmdClearAttachments, pattern VkCmdClearAttachments, HS_vkCmdClearAttachments, PFN_vkCmdClearAttachments, vkCmdClearAttachments, vkCmdClearAttachmentsUnsafe, vkCmdClearAttachmentsSafe, VkCmdResolveImage, pattern VkCmdResolveImage, HS_vkCmdResolveImage, PFN_vkCmdResolveImage, vkCmdResolveImage, vkCmdResolveImageUnsafe, vkCmdResolveImageSafe, VkCmdSetEvent, pattern VkCmdSetEvent, HS_vkCmdSetEvent, PFN_vkCmdSetEvent, vkCmdSetEvent, vkCmdSetEventUnsafe, vkCmdSetEventSafe, VkCmdResetEvent, pattern VkCmdResetEvent, HS_vkCmdResetEvent, PFN_vkCmdResetEvent, vkCmdResetEvent, vkCmdResetEventUnsafe, vkCmdResetEventSafe, VkCmdWaitEvents, pattern VkCmdWaitEvents, HS_vkCmdWaitEvents, PFN_vkCmdWaitEvents, vkCmdWaitEvents, vkCmdWaitEventsUnsafe, vkCmdWaitEventsSafe, VkCmdPipelineBarrier, pattern VkCmdPipelineBarrier, HS_vkCmdPipelineBarrier, PFN_vkCmdPipelineBarrier, vkCmdPipelineBarrier, vkCmdPipelineBarrierUnsafe, vkCmdPipelineBarrierSafe, VkCmdBeginQuery, pattern VkCmdBeginQuery, HS_vkCmdBeginQuery, PFN_vkCmdBeginQuery, vkCmdBeginQuery, vkCmdBeginQueryUnsafe, vkCmdBeginQuerySafe, VkCmdEndQuery, pattern VkCmdEndQuery, HS_vkCmdEndQuery, PFN_vkCmdEndQuery, vkCmdEndQuery, vkCmdEndQueryUnsafe, vkCmdEndQuerySafe, VkCmdResetQueryPool, pattern VkCmdResetQueryPool, HS_vkCmdResetQueryPool, PFN_vkCmdResetQueryPool, vkCmdResetQueryPool, vkCmdResetQueryPoolUnsafe, vkCmdResetQueryPoolSafe, VkCmdWriteTimestamp, pattern VkCmdWriteTimestamp, HS_vkCmdWriteTimestamp, PFN_vkCmdWriteTimestamp, vkCmdWriteTimestamp, vkCmdWriteTimestampUnsafe, vkCmdWriteTimestampSafe, VkCmdCopyQueryPoolResults, pattern VkCmdCopyQueryPoolResults, HS_vkCmdCopyQueryPoolResults, PFN_vkCmdCopyQueryPoolResults, vkCmdCopyQueryPoolResults, vkCmdCopyQueryPoolResultsUnsafe, vkCmdCopyQueryPoolResultsSafe, VkCmdPushConstants, pattern VkCmdPushConstants, HS_vkCmdPushConstants, PFN_vkCmdPushConstants, vkCmdPushConstants, vkCmdPushConstantsUnsafe, vkCmdPushConstantsSafe, VkCmdBeginRenderPass, pattern VkCmdBeginRenderPass, HS_vkCmdBeginRenderPass, PFN_vkCmdBeginRenderPass, vkCmdBeginRenderPass, vkCmdBeginRenderPassUnsafe, vkCmdBeginRenderPassSafe, VkCmdNextSubpass, pattern VkCmdNextSubpass, HS_vkCmdNextSubpass, PFN_vkCmdNextSubpass, vkCmdNextSubpass, vkCmdNextSubpassUnsafe, vkCmdNextSubpassSafe, VkCmdEndRenderPass, pattern VkCmdEndRenderPass, HS_vkCmdEndRenderPass, PFN_vkCmdEndRenderPass, vkCmdEndRenderPass, vkCmdEndRenderPassUnsafe, vkCmdEndRenderPassSafe, VkCmdExecuteCommands, pattern VkCmdExecuteCommands, HS_vkCmdExecuteCommands, PFN_vkCmdExecuteCommands, vkCmdExecuteCommands, vkCmdExecuteCommandsUnsafe, vkCmdExecuteCommandsSafe) where import GHC.Ptr (Ptr (..)) import Graphics.Vulkan.Constants (pattern VK_ATTACHMENT_UNUSED, pattern VK_FALSE, pattern VK_LOD_CLAMP_NONE, pattern VK_QUEUE_FAMILY_IGNORED, pattern VK_REMAINING_ARRAY_LAYERS, pattern VK_REMAINING_MIP_LEVELS, pattern VK_SUBPASS_EXTERNAL, pattern VK_TRUE, pattern VK_WHOLE_SIZE) 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.Blend import Graphics.Vulkan.Types.Enum.BorderColor import Graphics.Vulkan.Types.Enum.Buffer import Graphics.Vulkan.Types.Enum.Color import Graphics.Vulkan.Types.Enum.Command import Graphics.Vulkan.Types.Enum.CompareOp import Graphics.Vulkan.Types.Enum.Component import Graphics.Vulkan.Types.Enum.CullModeFlags import Graphics.Vulkan.Types.Enum.DependencyFlags import Graphics.Vulkan.Types.Enum.Descriptor import Graphics.Vulkan.Types.Enum.Device import Graphics.Vulkan.Types.Enum.DynamicState import Graphics.Vulkan.Types.Enum.Fence import Graphics.Vulkan.Types.Enum.Filter import Graphics.Vulkan.Types.Enum.Format import Graphics.Vulkan.Types.Enum.FramebufferCreateFlags import Graphics.Vulkan.Types.Enum.FrontFace import Graphics.Vulkan.Types.Enum.Image import Graphics.Vulkan.Types.Enum.IndexType import Graphics.Vulkan.Types.Enum.InternalAllocationType import Graphics.Vulkan.Types.Enum.LogicOp import Graphics.Vulkan.Types.Enum.Memory import Graphics.Vulkan.Types.Enum.ObjectType import Graphics.Vulkan.Types.Enum.PhysicalDeviceType import Graphics.Vulkan.Types.Enum.Pipeline import Graphics.Vulkan.Types.Enum.PolygonMode import Graphics.Vulkan.Types.Enum.PrimitiveTopology 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.Shader import Graphics.Vulkan.Types.Enum.SharingMode import Graphics.Vulkan.Types.Enum.Sparse import Graphics.Vulkan.Types.Enum.Stencil import Graphics.Vulkan.Types.Enum.StructureType import Graphics.Vulkan.Types.Enum.Subpass import Graphics.Vulkan.Types.Enum.SystemAllocationScope import Graphics.Vulkan.Types.Enum.VendorId import Graphics.Vulkan.Types.Enum.VertexInputRate import Graphics.Vulkan.Types.Funcpointers import Graphics.Vulkan.Types.Handles import Graphics.Vulkan.Types.Struct.AllocationCallbacks import Graphics.Vulkan.Types.Struct.ApplicationInfo import Graphics.Vulkan.Types.Struct.Attachment import Graphics.Vulkan.Types.Struct.Base (VkBaseInStructure, VkBaseOutStructure) import Graphics.Vulkan.Types.Struct.Bind import Graphics.Vulkan.Types.Struct.Buffer import Graphics.Vulkan.Types.Struct.Clear import Graphics.Vulkan.Types.Struct.Command import Graphics.Vulkan.Types.Struct.ComponentMapping import Graphics.Vulkan.Types.Struct.ComputePipelineCreateInfo import Graphics.Vulkan.Types.Struct.CopyDescriptorSet import Graphics.Vulkan.Types.Struct.Descriptor import Graphics.Vulkan.Types.Struct.Device import Graphics.Vulkan.Types.Struct.DispatchIndirectCommand (VkDispatchIndirectCommand) import Graphics.Vulkan.Types.Struct.Draw (VkDrawIndexedIndirectCommand, VkDrawIndirectCommand) import Graphics.Vulkan.Types.Struct.EventCreateInfo import Graphics.Vulkan.Types.Struct.ExtensionProperties import Graphics.Vulkan.Types.Struct.Extent import Graphics.Vulkan.Types.Struct.Fence import Graphics.Vulkan.Types.Struct.FormatProperties import Graphics.Vulkan.Types.Struct.Framebuffer import Graphics.Vulkan.Types.Struct.Image import Graphics.Vulkan.Types.Struct.InstanceCreateInfo import Graphics.Vulkan.Types.Struct.LayerProperties import Graphics.Vulkan.Types.Struct.MappedMemoryRange import Graphics.Vulkan.Types.Struct.Memory import Graphics.Vulkan.Types.Struct.Offset import Graphics.Vulkan.Types.Struct.PhysicalDevice import Graphics.Vulkan.Types.Struct.PhysicalDeviceFeatures import Graphics.Vulkan.Types.Struct.Pipeline import Graphics.Vulkan.Types.Struct.PushConstantRange import Graphics.Vulkan.Types.Struct.QueryPool import Graphics.Vulkan.Types.Struct.QueueFamily import Graphics.Vulkan.Types.Struct.Rect import Graphics.Vulkan.Types.Struct.RenderPass import Graphics.Vulkan.Types.Struct.Sampler import Graphics.Vulkan.Types.Struct.Semaphore import Graphics.Vulkan.Types.Struct.Shader import Graphics.Vulkan.Types.Struct.Sparse import Graphics.Vulkan.Types.Struct.Specialization import Graphics.Vulkan.Types.Struct.StencilOpState import Graphics.Vulkan.Types.Struct.SubmitInfo import Graphics.Vulkan.Types.Struct.Subpass import Graphics.Vulkan.Types.Struct.SubresourceLayout import Graphics.Vulkan.Types.Struct.VertexInput import Graphics.Vulkan.Types.Struct.Viewport import Graphics.Vulkan.Types.Struct.WriteDescriptorSet import System.IO.Unsafe (unsafeDupablePerformIO) pattern VkCreateInstance :: CString pattern VkCreateInstance <- (is_VkCreateInstance -> True) where VkCreateInstance = _VkCreateInstance {-# INLINE _VkCreateInstance #-} _VkCreateInstance :: CString _VkCreateInstance = Ptr "vkCreateInstance\NUL"# {-# INLINE is_VkCreateInstance #-} is_VkCreateInstance :: CString -> Bool is_VkCreateInstance = (EQ ==) . cmpCStrings _VkCreateInstance type VkCreateInstance = "vkCreateInstance" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INITIALIZATION_FAILED', 'VK_ERROR_LAYER_NOT_PRESENT', 'VK_ERROR_EXTENSION_NOT_PRESENT', 'VK_ERROR_INCOMPATIBLE_DRIVER'. -- -- > VkResult vkCreateInstance -- > ( const VkInstanceCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkInstance* pInstance -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateInstance vkCreateInstance registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateInstance <- vkGetInstanceProc @VkCreateInstance VK_NULL -- -- or less efficient: -- -- > myCreateInstance <- vkGetProc @VkCreateInstance -- -- __Note:__ @vkCreateInstanceUnsafe@ and @vkCreateInstanceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateInstance@ is an alias -- of @vkCreateInstanceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateInstanceSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateInstance" vkCreateInstanceUnsafe :: Ptr VkInstanceCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkInstance -- ^ pInstance -> IO VkResult #else vkCreateInstanceUnsafe :: Ptr VkInstanceCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkInstance -- ^ pInstance -> IO VkResult vkCreateInstanceUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateInstance) {-# NOINLINE vkCreateInstanceUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INITIALIZATION_FAILED', 'VK_ERROR_LAYER_NOT_PRESENT', 'VK_ERROR_EXTENSION_NOT_PRESENT', 'VK_ERROR_INCOMPATIBLE_DRIVER'. -- -- > VkResult vkCreateInstance -- > ( const VkInstanceCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkInstance* pInstance -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateInstance vkCreateInstance registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateInstance <- vkGetInstanceProc @VkCreateInstance VK_NULL -- -- or less efficient: -- -- > myCreateInstance <- vkGetProc @VkCreateInstance -- -- __Note:__ @vkCreateInstanceUnsafe@ and @vkCreateInstanceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateInstance@ is an alias -- of @vkCreateInstanceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateInstanceSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateInstance" vkCreateInstanceSafe :: Ptr VkInstanceCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkInstance -- ^ pInstance -> IO VkResult #else vkCreateInstanceSafe :: Ptr VkInstanceCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkInstance -- ^ pInstance -> IO VkResult vkCreateInstanceSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateInstance) {-# NOINLINE vkCreateInstanceSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INITIALIZATION_FAILED', 'VK_ERROR_LAYER_NOT_PRESENT', 'VK_ERROR_EXTENSION_NOT_PRESENT', 'VK_ERROR_INCOMPATIBLE_DRIVER'. -- -- > VkResult vkCreateInstance -- > ( const VkInstanceCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkInstance* pInstance -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateInstance vkCreateInstance registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateInstance <- vkGetInstanceProc @VkCreateInstance VK_NULL -- -- or less efficient: -- -- > myCreateInstance <- vkGetProc @VkCreateInstance -- -- __Note:__ @vkCreateInstanceUnsafe@ and @vkCreateInstanceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateInstance@ is an alias -- of @vkCreateInstanceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateInstanceSafe@. -- vkCreateInstance :: Ptr VkInstanceCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkInstance -- ^ pInstance -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateInstance = vkCreateInstanceUnsafe #else vkCreateInstance = vkCreateInstanceSafe #endif {-# INLINE vkCreateInstance #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INITIALIZATION_FAILED', 'VK_ERROR_LAYER_NOT_PRESENT', 'VK_ERROR_EXTENSION_NOT_PRESENT', 'VK_ERROR_INCOMPATIBLE_DRIVER'. -- -- > VkResult vkCreateInstance -- > ( const VkInstanceCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkInstance* pInstance -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateInstance vkCreateInstance registry at www.khronos.org> type HS_vkCreateInstance = Ptr VkInstanceCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkInstance -- ^ pInstance -> IO VkResult type PFN_vkCreateInstance = FunPtr HS_vkCreateInstance foreign import ccall unsafe "dynamic" unwrapVkCreateInstanceUnsafe :: PFN_vkCreateInstance -> HS_vkCreateInstance foreign import ccall safe "dynamic" unwrapVkCreateInstanceSafe :: PFN_vkCreateInstance -> HS_vkCreateInstance instance VulkanProc "vkCreateInstance" where type VkProcType "vkCreateInstance" = HS_vkCreateInstance vkProcSymbol = _VkCreateInstance {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateInstanceUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateInstanceSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroyInstance :: CString pattern VkDestroyInstance <- (is_VkDestroyInstance -> True) where VkDestroyInstance = _VkDestroyInstance {-# INLINE _VkDestroyInstance #-} _VkDestroyInstance :: CString _VkDestroyInstance = Ptr "vkDestroyInstance\NUL"# {-# INLINE is_VkDestroyInstance #-} is_VkDestroyInstance :: CString -> Bool is_VkDestroyInstance = (EQ ==) . cmpCStrings _VkDestroyInstance type VkDestroyInstance = "vkDestroyInstance" -- | -- > void vkDestroyInstance -- > ( VkInstance instance -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyInstance vkDestroyInstance registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyInstance <- vkGetInstanceProc @VkDestroyInstance vkInstance -- -- or less efficient: -- -- > myDestroyInstance <- vkGetProc @VkDestroyInstance -- -- __Note:__ @vkDestroyInstanceUnsafe@ and @vkDestroyInstanceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyInstance@ is an alias -- of @vkDestroyInstanceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyInstanceSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroyInstance" vkDestroyInstanceUnsafe :: VkInstance -- ^ instance -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyInstanceUnsafe :: VkInstance -- ^ instance -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyInstanceUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroyInstance) {-# NOINLINE vkDestroyInstanceUnsafe #-} #endif -- | -- > void vkDestroyInstance -- > ( VkInstance instance -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyInstance vkDestroyInstance registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyInstance <- vkGetInstanceProc @VkDestroyInstance vkInstance -- -- or less efficient: -- -- > myDestroyInstance <- vkGetProc @VkDestroyInstance -- -- __Note:__ @vkDestroyInstanceUnsafe@ and @vkDestroyInstanceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyInstance@ is an alias -- of @vkDestroyInstanceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyInstanceSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroyInstance" vkDestroyInstanceSafe :: VkInstance -- ^ instance -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyInstanceSafe :: VkInstance -- ^ instance -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyInstanceSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroyInstance) {-# NOINLINE vkDestroyInstanceSafe #-} #endif -- | -- > void vkDestroyInstance -- > ( VkInstance instance -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyInstance vkDestroyInstance registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyInstance <- vkGetInstanceProc @VkDestroyInstance vkInstance -- -- or less efficient: -- -- > myDestroyInstance <- vkGetProc @VkDestroyInstance -- -- __Note:__ @vkDestroyInstanceUnsafe@ and @vkDestroyInstanceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyInstance@ is an alias -- of @vkDestroyInstanceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyInstanceSafe@. -- vkDestroyInstance :: VkInstance -- ^ instance -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroyInstance = vkDestroyInstanceUnsafe #else vkDestroyInstance = vkDestroyInstanceSafe #endif {-# INLINE vkDestroyInstance #-} -- | > void vkDestroyInstance -- > ( VkInstance instance -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyInstance vkDestroyInstance registry at www.khronos.org> type HS_vkDestroyInstance = VkInstance -- ^ instance -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroyInstance = FunPtr HS_vkDestroyInstance foreign import ccall unsafe "dynamic" unwrapVkDestroyInstanceUnsafe :: PFN_vkDestroyInstance -> HS_vkDestroyInstance foreign import ccall safe "dynamic" unwrapVkDestroyInstanceSafe :: PFN_vkDestroyInstance -> HS_vkDestroyInstance instance VulkanProc "vkDestroyInstance" where type VkProcType "vkDestroyInstance" = HS_vkDestroyInstance vkProcSymbol = _VkDestroyInstance {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroyInstanceUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroyInstanceSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkEnumeratePhysicalDevices :: CString pattern VkEnumeratePhysicalDevices <- (is_VkEnumeratePhysicalDevices -> True) where VkEnumeratePhysicalDevices = _VkEnumeratePhysicalDevices {-# INLINE _VkEnumeratePhysicalDevices #-} _VkEnumeratePhysicalDevices :: CString _VkEnumeratePhysicalDevices = Ptr "vkEnumeratePhysicalDevices\NUL"# {-# INLINE is_VkEnumeratePhysicalDevices #-} is_VkEnumeratePhysicalDevices :: CString -> Bool is_VkEnumeratePhysicalDevices = (EQ ==) . cmpCStrings _VkEnumeratePhysicalDevices type VkEnumeratePhysicalDevices = "vkEnumeratePhysicalDevices" -- | -- 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 vkEnumeratePhysicalDevices -- > ( VkInstance instance -- > , uint32_t* pPhysicalDeviceCount -- > , VkPhysicalDevice* pPhysicalDevices -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myEnumeratePhysicalDevices <- vkGetInstanceProc @VkEnumeratePhysicalDevices vkInstance -- -- or less efficient: -- -- > myEnumeratePhysicalDevices <- vkGetProc @VkEnumeratePhysicalDevices -- -- __Note:__ @vkEnumeratePhysicalDevicesUnsafe@ and @vkEnumeratePhysicalDevicesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkEnumeratePhysicalDevices@ is an alias -- of @vkEnumeratePhysicalDevicesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkEnumeratePhysicalDevicesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkEnumeratePhysicalDevices" vkEnumeratePhysicalDevicesUnsafe :: VkInstance -- ^ instance -> Ptr Word32 -- ^ pPhysicalDeviceCount -> Ptr VkPhysicalDevice -- ^ pPhysicalDevices -> IO VkResult #else vkEnumeratePhysicalDevicesUnsafe :: VkInstance -- ^ instance -> Ptr Word32 -- ^ pPhysicalDeviceCount -> Ptr VkPhysicalDevice -- ^ pPhysicalDevices -> IO VkResult vkEnumeratePhysicalDevicesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkEnumeratePhysicalDevices) {-# NOINLINE vkEnumeratePhysicalDevicesUnsafe #-} #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 vkEnumeratePhysicalDevices -- > ( VkInstance instance -- > , uint32_t* pPhysicalDeviceCount -- > , VkPhysicalDevice* pPhysicalDevices -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myEnumeratePhysicalDevices <- vkGetInstanceProc @VkEnumeratePhysicalDevices vkInstance -- -- or less efficient: -- -- > myEnumeratePhysicalDevices <- vkGetProc @VkEnumeratePhysicalDevices -- -- __Note:__ @vkEnumeratePhysicalDevicesUnsafe@ and @vkEnumeratePhysicalDevicesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkEnumeratePhysicalDevices@ is an alias -- of @vkEnumeratePhysicalDevicesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkEnumeratePhysicalDevicesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkEnumeratePhysicalDevices" vkEnumeratePhysicalDevicesSafe :: VkInstance -- ^ instance -> Ptr Word32 -- ^ pPhysicalDeviceCount -> Ptr VkPhysicalDevice -- ^ pPhysicalDevices -> IO VkResult #else vkEnumeratePhysicalDevicesSafe :: VkInstance -- ^ instance -> Ptr Word32 -- ^ pPhysicalDeviceCount -> Ptr VkPhysicalDevice -- ^ pPhysicalDevices -> IO VkResult vkEnumeratePhysicalDevicesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkEnumeratePhysicalDevices) {-# NOINLINE vkEnumeratePhysicalDevicesSafe #-} #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 vkEnumeratePhysicalDevices -- > ( VkInstance instance -- > , uint32_t* pPhysicalDeviceCount -- > , VkPhysicalDevice* pPhysicalDevices -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myEnumeratePhysicalDevices <- vkGetInstanceProc @VkEnumeratePhysicalDevices vkInstance -- -- or less efficient: -- -- > myEnumeratePhysicalDevices <- vkGetProc @VkEnumeratePhysicalDevices -- -- __Note:__ @vkEnumeratePhysicalDevicesUnsafe@ and @vkEnumeratePhysicalDevicesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkEnumeratePhysicalDevices@ is an alias -- of @vkEnumeratePhysicalDevicesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkEnumeratePhysicalDevicesSafe@. -- vkEnumeratePhysicalDevices :: VkInstance -- ^ instance -> Ptr Word32 -- ^ pPhysicalDeviceCount -> Ptr VkPhysicalDevice -- ^ pPhysicalDevices -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkEnumeratePhysicalDevices = vkEnumeratePhysicalDevicesUnsafe #else vkEnumeratePhysicalDevices = vkEnumeratePhysicalDevicesSafe #endif {-# INLINE vkEnumeratePhysicalDevices #-} -- | 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 vkEnumeratePhysicalDevices -- > ( VkInstance instance -- > , uint32_t* pPhysicalDeviceCount -- > , VkPhysicalDevice* pPhysicalDevices -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices registry at www.khronos.org> type HS_vkEnumeratePhysicalDevices = VkInstance -- ^ instance -> Ptr Word32 -- ^ pPhysicalDeviceCount -> Ptr VkPhysicalDevice -- ^ pPhysicalDevices -> IO VkResult type PFN_vkEnumeratePhysicalDevices = FunPtr HS_vkEnumeratePhysicalDevices foreign import ccall unsafe "dynamic" unwrapVkEnumeratePhysicalDevicesUnsafe :: PFN_vkEnumeratePhysicalDevices -> HS_vkEnumeratePhysicalDevices foreign import ccall safe "dynamic" unwrapVkEnumeratePhysicalDevicesSafe :: PFN_vkEnumeratePhysicalDevices -> HS_vkEnumeratePhysicalDevices instance VulkanProc "vkEnumeratePhysicalDevices" where type VkProcType "vkEnumeratePhysicalDevices" = HS_vkEnumeratePhysicalDevices vkProcSymbol = _VkEnumeratePhysicalDevices {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkEnumeratePhysicalDevicesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkEnumeratePhysicalDevicesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetPhysicalDeviceFeatures :: CString pattern VkGetPhysicalDeviceFeatures <- (is_VkGetPhysicalDeviceFeatures -> True) where VkGetPhysicalDeviceFeatures = _VkGetPhysicalDeviceFeatures {-# INLINE _VkGetPhysicalDeviceFeatures #-} _VkGetPhysicalDeviceFeatures :: CString _VkGetPhysicalDeviceFeatures = Ptr "vkGetPhysicalDeviceFeatures\NUL"# {-# INLINE is_VkGetPhysicalDeviceFeatures #-} is_VkGetPhysicalDeviceFeatures :: CString -> Bool is_VkGetPhysicalDeviceFeatures = (EQ ==) . cmpCStrings _VkGetPhysicalDeviceFeatures type VkGetPhysicalDeviceFeatures = "vkGetPhysicalDeviceFeatures" -- | -- > void vkGetPhysicalDeviceFeatures -- > ( VkPhysicalDevice physicalDevice -- > , VkPhysicalDeviceFeatures* pFeatures -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceFeatures <- vkGetInstanceProc @VkGetPhysicalDeviceFeatures vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceFeatures <- vkGetProc @VkGetPhysicalDeviceFeatures -- -- __Note:__ @vkGetPhysicalDeviceFeaturesUnsafe@ and @vkGetPhysicalDeviceFeaturesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceFeatures@ is an alias -- of @vkGetPhysicalDeviceFeaturesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceFeaturesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetPhysicalDeviceFeatures" vkGetPhysicalDeviceFeaturesUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkPhysicalDeviceFeatures -- ^ pFeatures -> IO () #else vkGetPhysicalDeviceFeaturesUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkPhysicalDeviceFeatures -- ^ pFeatures -> IO () vkGetPhysicalDeviceFeaturesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetPhysicalDeviceFeatures) {-# NOINLINE vkGetPhysicalDeviceFeaturesUnsafe #-} #endif -- | -- > void vkGetPhysicalDeviceFeatures -- > ( VkPhysicalDevice physicalDevice -- > , VkPhysicalDeviceFeatures* pFeatures -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceFeatures <- vkGetInstanceProc @VkGetPhysicalDeviceFeatures vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceFeatures <- vkGetProc @VkGetPhysicalDeviceFeatures -- -- __Note:__ @vkGetPhysicalDeviceFeaturesUnsafe@ and @vkGetPhysicalDeviceFeaturesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceFeatures@ is an alias -- of @vkGetPhysicalDeviceFeaturesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceFeaturesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetPhysicalDeviceFeatures" vkGetPhysicalDeviceFeaturesSafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkPhysicalDeviceFeatures -- ^ pFeatures -> IO () #else vkGetPhysicalDeviceFeaturesSafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkPhysicalDeviceFeatures -- ^ pFeatures -> IO () vkGetPhysicalDeviceFeaturesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetPhysicalDeviceFeatures) {-# NOINLINE vkGetPhysicalDeviceFeaturesSafe #-} #endif -- | -- > void vkGetPhysicalDeviceFeatures -- > ( VkPhysicalDevice physicalDevice -- > , VkPhysicalDeviceFeatures* pFeatures -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceFeatures <- vkGetInstanceProc @VkGetPhysicalDeviceFeatures vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceFeatures <- vkGetProc @VkGetPhysicalDeviceFeatures -- -- __Note:__ @vkGetPhysicalDeviceFeaturesUnsafe@ and @vkGetPhysicalDeviceFeaturesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceFeatures@ is an alias -- of @vkGetPhysicalDeviceFeaturesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceFeaturesSafe@. -- vkGetPhysicalDeviceFeatures :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkPhysicalDeviceFeatures -- ^ pFeatures -> IO () #ifdef UNSAFE_FFI_DEFAULT vkGetPhysicalDeviceFeatures = vkGetPhysicalDeviceFeaturesUnsafe #else vkGetPhysicalDeviceFeatures = vkGetPhysicalDeviceFeaturesSafe #endif {-# INLINE vkGetPhysicalDeviceFeatures #-} -- | > void vkGetPhysicalDeviceFeatures -- > ( VkPhysicalDevice physicalDevice -- > , VkPhysicalDeviceFeatures* pFeatures -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures registry at www.khronos.org> type HS_vkGetPhysicalDeviceFeatures = VkPhysicalDevice -- ^ physicalDevice -> Ptr VkPhysicalDeviceFeatures -- ^ pFeatures -> IO () type PFN_vkGetPhysicalDeviceFeatures = FunPtr HS_vkGetPhysicalDeviceFeatures foreign import ccall unsafe "dynamic" unwrapVkGetPhysicalDeviceFeaturesUnsafe :: PFN_vkGetPhysicalDeviceFeatures -> HS_vkGetPhysicalDeviceFeatures foreign import ccall safe "dynamic" unwrapVkGetPhysicalDeviceFeaturesSafe :: PFN_vkGetPhysicalDeviceFeatures -> HS_vkGetPhysicalDeviceFeatures instance VulkanProc "vkGetPhysicalDeviceFeatures" where type VkProcType "vkGetPhysicalDeviceFeatures" = HS_vkGetPhysicalDeviceFeatures vkProcSymbol = _VkGetPhysicalDeviceFeatures {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetPhysicalDeviceFeaturesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetPhysicalDeviceFeaturesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetPhysicalDeviceFormatProperties :: CString pattern VkGetPhysicalDeviceFormatProperties <- (is_VkGetPhysicalDeviceFormatProperties -> True) where VkGetPhysicalDeviceFormatProperties = _VkGetPhysicalDeviceFormatProperties {-# INLINE _VkGetPhysicalDeviceFormatProperties #-} _VkGetPhysicalDeviceFormatProperties :: CString _VkGetPhysicalDeviceFormatProperties = Ptr "vkGetPhysicalDeviceFormatProperties\NUL"# {-# INLINE is_VkGetPhysicalDeviceFormatProperties #-} is_VkGetPhysicalDeviceFormatProperties :: CString -> Bool is_VkGetPhysicalDeviceFormatProperties = (EQ ==) . cmpCStrings _VkGetPhysicalDeviceFormatProperties type VkGetPhysicalDeviceFormatProperties = "vkGetPhysicalDeviceFormatProperties" -- | -- > void vkGetPhysicalDeviceFormatProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkFormat format -- > , VkFormatProperties* pFormatProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceFormatProperties <- vkGetInstanceProc @VkGetPhysicalDeviceFormatProperties vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceFormatProperties <- vkGetProc @VkGetPhysicalDeviceFormatProperties -- -- __Note:__ @vkGetPhysicalDeviceFormatPropertiesUnsafe@ and @vkGetPhysicalDeviceFormatPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceFormatProperties@ is an alias -- of @vkGetPhysicalDeviceFormatPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceFormatPropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetPhysicalDeviceFormatProperties" vkGetPhysicalDeviceFormatPropertiesUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> VkFormat -- ^ format -> Ptr VkFormatProperties -- ^ pFormatProperties -> IO () #else vkGetPhysicalDeviceFormatPropertiesUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> VkFormat -- ^ format -> Ptr VkFormatProperties -- ^ pFormatProperties -> IO () vkGetPhysicalDeviceFormatPropertiesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetPhysicalDeviceFormatProperties) {-# NOINLINE vkGetPhysicalDeviceFormatPropertiesUnsafe #-} #endif -- | -- > void vkGetPhysicalDeviceFormatProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkFormat format -- > , VkFormatProperties* pFormatProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceFormatProperties <- vkGetInstanceProc @VkGetPhysicalDeviceFormatProperties vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceFormatProperties <- vkGetProc @VkGetPhysicalDeviceFormatProperties -- -- __Note:__ @vkGetPhysicalDeviceFormatPropertiesUnsafe@ and @vkGetPhysicalDeviceFormatPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceFormatProperties@ is an alias -- of @vkGetPhysicalDeviceFormatPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceFormatPropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetPhysicalDeviceFormatProperties" vkGetPhysicalDeviceFormatPropertiesSafe :: VkPhysicalDevice -- ^ physicalDevice -> VkFormat -- ^ format -> Ptr VkFormatProperties -- ^ pFormatProperties -> IO () #else vkGetPhysicalDeviceFormatPropertiesSafe :: VkPhysicalDevice -- ^ physicalDevice -> VkFormat -- ^ format -> Ptr VkFormatProperties -- ^ pFormatProperties -> IO () vkGetPhysicalDeviceFormatPropertiesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetPhysicalDeviceFormatProperties) {-# NOINLINE vkGetPhysicalDeviceFormatPropertiesSafe #-} #endif -- | -- > void vkGetPhysicalDeviceFormatProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkFormat format -- > , VkFormatProperties* pFormatProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceFormatProperties <- vkGetInstanceProc @VkGetPhysicalDeviceFormatProperties vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceFormatProperties <- vkGetProc @VkGetPhysicalDeviceFormatProperties -- -- __Note:__ @vkGetPhysicalDeviceFormatPropertiesUnsafe@ and @vkGetPhysicalDeviceFormatPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceFormatProperties@ is an alias -- of @vkGetPhysicalDeviceFormatPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceFormatPropertiesSafe@. -- vkGetPhysicalDeviceFormatProperties :: VkPhysicalDevice -- ^ physicalDevice -> VkFormat -- ^ format -> Ptr VkFormatProperties -- ^ pFormatProperties -> IO () #ifdef UNSAFE_FFI_DEFAULT vkGetPhysicalDeviceFormatProperties = vkGetPhysicalDeviceFormatPropertiesUnsafe #else vkGetPhysicalDeviceFormatProperties = vkGetPhysicalDeviceFormatPropertiesSafe #endif {-# INLINE vkGetPhysicalDeviceFormatProperties #-} -- | > void vkGetPhysicalDeviceFormatProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkFormat format -- > , VkFormatProperties* pFormatProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties registry at www.khronos.org> type HS_vkGetPhysicalDeviceFormatProperties = VkPhysicalDevice -- ^ physicalDevice -> VkFormat -- ^ format -> Ptr VkFormatProperties -- ^ pFormatProperties -> IO () type PFN_vkGetPhysicalDeviceFormatProperties = FunPtr HS_vkGetPhysicalDeviceFormatProperties foreign import ccall unsafe "dynamic" unwrapVkGetPhysicalDeviceFormatPropertiesUnsafe :: PFN_vkGetPhysicalDeviceFormatProperties -> HS_vkGetPhysicalDeviceFormatProperties foreign import ccall safe "dynamic" unwrapVkGetPhysicalDeviceFormatPropertiesSafe :: PFN_vkGetPhysicalDeviceFormatProperties -> HS_vkGetPhysicalDeviceFormatProperties instance VulkanProc "vkGetPhysicalDeviceFormatProperties" where type VkProcType "vkGetPhysicalDeviceFormatProperties" = HS_vkGetPhysicalDeviceFormatProperties vkProcSymbol = _VkGetPhysicalDeviceFormatProperties {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetPhysicalDeviceFormatPropertiesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetPhysicalDeviceFormatPropertiesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetPhysicalDeviceImageFormatProperties :: CString pattern VkGetPhysicalDeviceImageFormatProperties <- (is_VkGetPhysicalDeviceImageFormatProperties -> True) where VkGetPhysicalDeviceImageFormatProperties = _VkGetPhysicalDeviceImageFormatProperties {-# INLINE _VkGetPhysicalDeviceImageFormatProperties #-} _VkGetPhysicalDeviceImageFormatProperties :: CString _VkGetPhysicalDeviceImageFormatProperties = Ptr "vkGetPhysicalDeviceImageFormatProperties\NUL"# {-# INLINE is_VkGetPhysicalDeviceImageFormatProperties #-} is_VkGetPhysicalDeviceImageFormatProperties :: CString -> Bool is_VkGetPhysicalDeviceImageFormatProperties = (EQ ==) . cmpCStrings _VkGetPhysicalDeviceImageFormatProperties type VkGetPhysicalDeviceImageFormatProperties = "vkGetPhysicalDeviceImageFormatProperties" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_FORMAT_NOT_SUPPORTED'. -- -- > VkResult vkGetPhysicalDeviceImageFormatProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkFormat format -- > , VkImageType type -- > , VkImageTiling tiling -- > , VkImageUsageFlags usage -- > , VkImageCreateFlags flags -- > , VkImageFormatProperties* pImageFormatProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceImageFormatProperties <- vkGetInstanceProc @VkGetPhysicalDeviceImageFormatProperties vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceImageFormatProperties <- vkGetProc @VkGetPhysicalDeviceImageFormatProperties -- -- __Note:__ @vkGetPhysicalDeviceImageFormatPropertiesUnsafe@ and @vkGetPhysicalDeviceImageFormatPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceImageFormatProperties@ is an alias -- of @vkGetPhysicalDeviceImageFormatPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceImageFormatPropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetPhysicalDeviceImageFormatProperties" vkGetPhysicalDeviceImageFormatPropertiesUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> VkFormat -- ^ format -> VkImageType -- ^ type -> VkImageTiling -- ^ tiling -> VkImageUsageFlags -- ^ usage -> VkImageCreateFlags -- ^ flags -> Ptr VkImageFormatProperties -- ^ pImageFormatProperties -> IO VkResult #else vkGetPhysicalDeviceImageFormatPropertiesUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> VkFormat -- ^ format -> VkImageType -- ^ type -> VkImageTiling -- ^ tiling -> VkImageUsageFlags -- ^ usage -> VkImageCreateFlags -- ^ flags -> Ptr VkImageFormatProperties -- ^ pImageFormatProperties -> IO VkResult vkGetPhysicalDeviceImageFormatPropertiesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetPhysicalDeviceImageFormatProperties) {-# NOINLINE vkGetPhysicalDeviceImageFormatPropertiesUnsafe #-} #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 vkGetPhysicalDeviceImageFormatProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkFormat format -- > , VkImageType type -- > , VkImageTiling tiling -- > , VkImageUsageFlags usage -- > , VkImageCreateFlags flags -- > , VkImageFormatProperties* pImageFormatProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceImageFormatProperties <- vkGetInstanceProc @VkGetPhysicalDeviceImageFormatProperties vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceImageFormatProperties <- vkGetProc @VkGetPhysicalDeviceImageFormatProperties -- -- __Note:__ @vkGetPhysicalDeviceImageFormatPropertiesUnsafe@ and @vkGetPhysicalDeviceImageFormatPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceImageFormatProperties@ is an alias -- of @vkGetPhysicalDeviceImageFormatPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceImageFormatPropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetPhysicalDeviceImageFormatProperties" vkGetPhysicalDeviceImageFormatPropertiesSafe :: VkPhysicalDevice -- ^ physicalDevice -> VkFormat -- ^ format -> VkImageType -- ^ type -> VkImageTiling -- ^ tiling -> VkImageUsageFlags -- ^ usage -> VkImageCreateFlags -- ^ flags -> Ptr VkImageFormatProperties -- ^ pImageFormatProperties -> IO VkResult #else vkGetPhysicalDeviceImageFormatPropertiesSafe :: VkPhysicalDevice -- ^ physicalDevice -> VkFormat -- ^ format -> VkImageType -- ^ type -> VkImageTiling -- ^ tiling -> VkImageUsageFlags -- ^ usage -> VkImageCreateFlags -- ^ flags -> Ptr VkImageFormatProperties -- ^ pImageFormatProperties -> IO VkResult vkGetPhysicalDeviceImageFormatPropertiesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetPhysicalDeviceImageFormatProperties) {-# NOINLINE vkGetPhysicalDeviceImageFormatPropertiesSafe #-} #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 vkGetPhysicalDeviceImageFormatProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkFormat format -- > , VkImageType type -- > , VkImageTiling tiling -- > , VkImageUsageFlags usage -- > , VkImageCreateFlags flags -- > , VkImageFormatProperties* pImageFormatProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceImageFormatProperties <- vkGetInstanceProc @VkGetPhysicalDeviceImageFormatProperties vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceImageFormatProperties <- vkGetProc @VkGetPhysicalDeviceImageFormatProperties -- -- __Note:__ @vkGetPhysicalDeviceImageFormatPropertiesUnsafe@ and @vkGetPhysicalDeviceImageFormatPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceImageFormatProperties@ is an alias -- of @vkGetPhysicalDeviceImageFormatPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceImageFormatPropertiesSafe@. -- vkGetPhysicalDeviceImageFormatProperties :: VkPhysicalDevice -- ^ physicalDevice -> VkFormat -- ^ format -> VkImageType -- ^ type -> VkImageTiling -- ^ tiling -> VkImageUsageFlags -- ^ usage -> VkImageCreateFlags -- ^ flags -> Ptr VkImageFormatProperties -- ^ pImageFormatProperties -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkGetPhysicalDeviceImageFormatProperties = vkGetPhysicalDeviceImageFormatPropertiesUnsafe #else vkGetPhysicalDeviceImageFormatProperties = vkGetPhysicalDeviceImageFormatPropertiesSafe #endif {-# INLINE vkGetPhysicalDeviceImageFormatProperties #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_FORMAT_NOT_SUPPORTED'. -- -- > VkResult vkGetPhysicalDeviceImageFormatProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkFormat format -- > , VkImageType type -- > , VkImageTiling tiling -- > , VkImageUsageFlags usage -- > , VkImageCreateFlags flags -- > , VkImageFormatProperties* pImageFormatProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties registry at www.khronos.org> type HS_vkGetPhysicalDeviceImageFormatProperties = VkPhysicalDevice -- ^ physicalDevice -> VkFormat -- ^ format -> VkImageType -- ^ type -> VkImageTiling -- ^ tiling -> VkImageUsageFlags -- ^ usage -> VkImageCreateFlags -- ^ flags -> Ptr VkImageFormatProperties -- ^ pImageFormatProperties -> IO VkResult type PFN_vkGetPhysicalDeviceImageFormatProperties = FunPtr HS_vkGetPhysicalDeviceImageFormatProperties foreign import ccall unsafe "dynamic" unwrapVkGetPhysicalDeviceImageFormatPropertiesUnsafe :: PFN_vkGetPhysicalDeviceImageFormatProperties -> HS_vkGetPhysicalDeviceImageFormatProperties foreign import ccall safe "dynamic" unwrapVkGetPhysicalDeviceImageFormatPropertiesSafe :: PFN_vkGetPhysicalDeviceImageFormatProperties -> HS_vkGetPhysicalDeviceImageFormatProperties instance VulkanProc "vkGetPhysicalDeviceImageFormatProperties" where type VkProcType "vkGetPhysicalDeviceImageFormatProperties" = HS_vkGetPhysicalDeviceImageFormatProperties vkProcSymbol = _VkGetPhysicalDeviceImageFormatProperties {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetPhysicalDeviceImageFormatPropertiesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetPhysicalDeviceImageFormatPropertiesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetPhysicalDeviceProperties :: CString pattern VkGetPhysicalDeviceProperties <- (is_VkGetPhysicalDeviceProperties -> True) where VkGetPhysicalDeviceProperties = _VkGetPhysicalDeviceProperties {-# INLINE _VkGetPhysicalDeviceProperties #-} _VkGetPhysicalDeviceProperties :: CString _VkGetPhysicalDeviceProperties = Ptr "vkGetPhysicalDeviceProperties\NUL"# {-# INLINE is_VkGetPhysicalDeviceProperties #-} is_VkGetPhysicalDeviceProperties :: CString -> Bool is_VkGetPhysicalDeviceProperties = (EQ ==) . cmpCStrings _VkGetPhysicalDeviceProperties type VkGetPhysicalDeviceProperties = "vkGetPhysicalDeviceProperties" -- | -- > void vkGetPhysicalDeviceProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkPhysicalDeviceProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceProperties <- vkGetInstanceProc @VkGetPhysicalDeviceProperties vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceProperties <- vkGetProc @VkGetPhysicalDeviceProperties -- -- __Note:__ @vkGetPhysicalDevicePropertiesUnsafe@ and @vkGetPhysicalDevicePropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceProperties@ is an alias -- of @vkGetPhysicalDevicePropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDevicePropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetPhysicalDeviceProperties" vkGetPhysicalDevicePropertiesUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkPhysicalDeviceProperties -- ^ pProperties -> IO () #else vkGetPhysicalDevicePropertiesUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkPhysicalDeviceProperties -- ^ pProperties -> IO () vkGetPhysicalDevicePropertiesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetPhysicalDeviceProperties) {-# NOINLINE vkGetPhysicalDevicePropertiesUnsafe #-} #endif -- | -- > void vkGetPhysicalDeviceProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkPhysicalDeviceProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceProperties <- vkGetInstanceProc @VkGetPhysicalDeviceProperties vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceProperties <- vkGetProc @VkGetPhysicalDeviceProperties -- -- __Note:__ @vkGetPhysicalDevicePropertiesUnsafe@ and @vkGetPhysicalDevicePropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceProperties@ is an alias -- of @vkGetPhysicalDevicePropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDevicePropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetPhysicalDeviceProperties" vkGetPhysicalDevicePropertiesSafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkPhysicalDeviceProperties -- ^ pProperties -> IO () #else vkGetPhysicalDevicePropertiesSafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkPhysicalDeviceProperties -- ^ pProperties -> IO () vkGetPhysicalDevicePropertiesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetPhysicalDeviceProperties) {-# NOINLINE vkGetPhysicalDevicePropertiesSafe #-} #endif -- | -- > void vkGetPhysicalDeviceProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkPhysicalDeviceProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceProperties <- vkGetInstanceProc @VkGetPhysicalDeviceProperties vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceProperties <- vkGetProc @VkGetPhysicalDeviceProperties -- -- __Note:__ @vkGetPhysicalDevicePropertiesUnsafe@ and @vkGetPhysicalDevicePropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceProperties@ is an alias -- of @vkGetPhysicalDevicePropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDevicePropertiesSafe@. -- vkGetPhysicalDeviceProperties :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkPhysicalDeviceProperties -- ^ pProperties -> IO () #ifdef UNSAFE_FFI_DEFAULT vkGetPhysicalDeviceProperties = vkGetPhysicalDevicePropertiesUnsafe #else vkGetPhysicalDeviceProperties = vkGetPhysicalDevicePropertiesSafe #endif {-# INLINE vkGetPhysicalDeviceProperties #-} -- | > void vkGetPhysicalDeviceProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkPhysicalDeviceProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties registry at www.khronos.org> type HS_vkGetPhysicalDeviceProperties = VkPhysicalDevice -- ^ physicalDevice -> Ptr VkPhysicalDeviceProperties -- ^ pProperties -> IO () type PFN_vkGetPhysicalDeviceProperties = FunPtr HS_vkGetPhysicalDeviceProperties foreign import ccall unsafe "dynamic" unwrapVkGetPhysicalDevicePropertiesUnsafe :: PFN_vkGetPhysicalDeviceProperties -> HS_vkGetPhysicalDeviceProperties foreign import ccall safe "dynamic" unwrapVkGetPhysicalDevicePropertiesSafe :: PFN_vkGetPhysicalDeviceProperties -> HS_vkGetPhysicalDeviceProperties instance VulkanProc "vkGetPhysicalDeviceProperties" where type VkProcType "vkGetPhysicalDeviceProperties" = HS_vkGetPhysicalDeviceProperties vkProcSymbol = _VkGetPhysicalDeviceProperties {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetPhysicalDevicePropertiesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetPhysicalDevicePropertiesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetPhysicalDeviceQueueFamilyProperties :: CString pattern VkGetPhysicalDeviceQueueFamilyProperties <- (is_VkGetPhysicalDeviceQueueFamilyProperties -> True) where VkGetPhysicalDeviceQueueFamilyProperties = _VkGetPhysicalDeviceQueueFamilyProperties {-# INLINE _VkGetPhysicalDeviceQueueFamilyProperties #-} _VkGetPhysicalDeviceQueueFamilyProperties :: CString _VkGetPhysicalDeviceQueueFamilyProperties = Ptr "vkGetPhysicalDeviceQueueFamilyProperties\NUL"# {-# INLINE is_VkGetPhysicalDeviceQueueFamilyProperties #-} is_VkGetPhysicalDeviceQueueFamilyProperties :: CString -> Bool is_VkGetPhysicalDeviceQueueFamilyProperties = (EQ ==) . cmpCStrings _VkGetPhysicalDeviceQueueFamilyProperties type VkGetPhysicalDeviceQueueFamilyProperties = "vkGetPhysicalDeviceQueueFamilyProperties" -- | -- > void vkGetPhysicalDeviceQueueFamilyProperties -- > ( VkPhysicalDevice physicalDevice -- > , uint32_t* pQueueFamilyPropertyCount -- > , VkQueueFamilyProperties* pQueueFamilyProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceQueueFamilyProperties <- vkGetInstanceProc @VkGetPhysicalDeviceQueueFamilyProperties vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceQueueFamilyProperties <- vkGetProc @VkGetPhysicalDeviceQueueFamilyProperties -- -- __Note:__ @vkGetPhysicalDeviceQueueFamilyPropertiesUnsafe@ and @vkGetPhysicalDeviceQueueFamilyPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceQueueFamilyProperties@ is an alias -- of @vkGetPhysicalDeviceQueueFamilyPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceQueueFamilyPropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetPhysicalDeviceQueueFamilyProperties" vkGetPhysicalDeviceQueueFamilyPropertiesUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr Word32 -- ^ pQueueFamilyPropertyCount -> Ptr VkQueueFamilyProperties -- ^ pQueueFamilyProperties -> IO () #else vkGetPhysicalDeviceQueueFamilyPropertiesUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr Word32 -- ^ pQueueFamilyPropertyCount -> Ptr VkQueueFamilyProperties -- ^ pQueueFamilyProperties -> IO () vkGetPhysicalDeviceQueueFamilyPropertiesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetPhysicalDeviceQueueFamilyProperties) {-# NOINLINE vkGetPhysicalDeviceQueueFamilyPropertiesUnsafe #-} #endif -- | -- > void vkGetPhysicalDeviceQueueFamilyProperties -- > ( VkPhysicalDevice physicalDevice -- > , uint32_t* pQueueFamilyPropertyCount -- > , VkQueueFamilyProperties* pQueueFamilyProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceQueueFamilyProperties <- vkGetInstanceProc @VkGetPhysicalDeviceQueueFamilyProperties vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceQueueFamilyProperties <- vkGetProc @VkGetPhysicalDeviceQueueFamilyProperties -- -- __Note:__ @vkGetPhysicalDeviceQueueFamilyPropertiesUnsafe@ and @vkGetPhysicalDeviceQueueFamilyPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceQueueFamilyProperties@ is an alias -- of @vkGetPhysicalDeviceQueueFamilyPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceQueueFamilyPropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetPhysicalDeviceQueueFamilyProperties" vkGetPhysicalDeviceQueueFamilyPropertiesSafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr Word32 -- ^ pQueueFamilyPropertyCount -> Ptr VkQueueFamilyProperties -- ^ pQueueFamilyProperties -> IO () #else vkGetPhysicalDeviceQueueFamilyPropertiesSafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr Word32 -- ^ pQueueFamilyPropertyCount -> Ptr VkQueueFamilyProperties -- ^ pQueueFamilyProperties -> IO () vkGetPhysicalDeviceQueueFamilyPropertiesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetPhysicalDeviceQueueFamilyProperties) {-# NOINLINE vkGetPhysicalDeviceQueueFamilyPropertiesSafe #-} #endif -- | -- > void vkGetPhysicalDeviceQueueFamilyProperties -- > ( VkPhysicalDevice physicalDevice -- > , uint32_t* pQueueFamilyPropertyCount -- > , VkQueueFamilyProperties* pQueueFamilyProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceQueueFamilyProperties <- vkGetInstanceProc @VkGetPhysicalDeviceQueueFamilyProperties vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceQueueFamilyProperties <- vkGetProc @VkGetPhysicalDeviceQueueFamilyProperties -- -- __Note:__ @vkGetPhysicalDeviceQueueFamilyPropertiesUnsafe@ and @vkGetPhysicalDeviceQueueFamilyPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceQueueFamilyProperties@ is an alias -- of @vkGetPhysicalDeviceQueueFamilyPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceQueueFamilyPropertiesSafe@. -- vkGetPhysicalDeviceQueueFamilyProperties :: VkPhysicalDevice -- ^ physicalDevice -> Ptr Word32 -- ^ pQueueFamilyPropertyCount -> Ptr VkQueueFamilyProperties -- ^ pQueueFamilyProperties -> IO () #ifdef UNSAFE_FFI_DEFAULT vkGetPhysicalDeviceQueueFamilyProperties = vkGetPhysicalDeviceQueueFamilyPropertiesUnsafe #else vkGetPhysicalDeviceQueueFamilyProperties = vkGetPhysicalDeviceQueueFamilyPropertiesSafe #endif {-# INLINE vkGetPhysicalDeviceQueueFamilyProperties #-} -- | > void vkGetPhysicalDeviceQueueFamilyProperties -- > ( VkPhysicalDevice physicalDevice -- > , uint32_t* pQueueFamilyPropertyCount -- > , VkQueueFamilyProperties* pQueueFamilyProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties registry at www.khronos.org> type HS_vkGetPhysicalDeviceQueueFamilyProperties = VkPhysicalDevice -- ^ physicalDevice -> Ptr Word32 -- ^ pQueueFamilyPropertyCount -> Ptr VkQueueFamilyProperties -- ^ pQueueFamilyProperties -> IO () type PFN_vkGetPhysicalDeviceQueueFamilyProperties = FunPtr HS_vkGetPhysicalDeviceQueueFamilyProperties foreign import ccall unsafe "dynamic" unwrapVkGetPhysicalDeviceQueueFamilyPropertiesUnsafe :: PFN_vkGetPhysicalDeviceQueueFamilyProperties -> HS_vkGetPhysicalDeviceQueueFamilyProperties foreign import ccall safe "dynamic" unwrapVkGetPhysicalDeviceQueueFamilyPropertiesSafe :: PFN_vkGetPhysicalDeviceQueueFamilyProperties -> HS_vkGetPhysicalDeviceQueueFamilyProperties instance VulkanProc "vkGetPhysicalDeviceQueueFamilyProperties" where type VkProcType "vkGetPhysicalDeviceQueueFamilyProperties" = HS_vkGetPhysicalDeviceQueueFamilyProperties vkProcSymbol = _VkGetPhysicalDeviceQueueFamilyProperties {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetPhysicalDeviceQueueFamilyPropertiesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetPhysicalDeviceQueueFamilyPropertiesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetPhysicalDeviceMemoryProperties :: CString pattern VkGetPhysicalDeviceMemoryProperties <- (is_VkGetPhysicalDeviceMemoryProperties -> True) where VkGetPhysicalDeviceMemoryProperties = _VkGetPhysicalDeviceMemoryProperties {-# INLINE _VkGetPhysicalDeviceMemoryProperties #-} _VkGetPhysicalDeviceMemoryProperties :: CString _VkGetPhysicalDeviceMemoryProperties = Ptr "vkGetPhysicalDeviceMemoryProperties\NUL"# {-# INLINE is_VkGetPhysicalDeviceMemoryProperties #-} is_VkGetPhysicalDeviceMemoryProperties :: CString -> Bool is_VkGetPhysicalDeviceMemoryProperties = (EQ ==) . cmpCStrings _VkGetPhysicalDeviceMemoryProperties type VkGetPhysicalDeviceMemoryProperties = "vkGetPhysicalDeviceMemoryProperties" -- | -- > void vkGetPhysicalDeviceMemoryProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkPhysicalDeviceMemoryProperties* pMemoryProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceMemoryProperties <- vkGetInstanceProc @VkGetPhysicalDeviceMemoryProperties vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceMemoryProperties <- vkGetProc @VkGetPhysicalDeviceMemoryProperties -- -- __Note:__ @vkGetPhysicalDeviceMemoryPropertiesUnsafe@ and @vkGetPhysicalDeviceMemoryPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceMemoryProperties@ is an alias -- of @vkGetPhysicalDeviceMemoryPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceMemoryPropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetPhysicalDeviceMemoryProperties" vkGetPhysicalDeviceMemoryPropertiesUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkPhysicalDeviceMemoryProperties -- ^ pMemoryProperties -> IO () #else vkGetPhysicalDeviceMemoryPropertiesUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkPhysicalDeviceMemoryProperties -- ^ pMemoryProperties -> IO () vkGetPhysicalDeviceMemoryPropertiesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetPhysicalDeviceMemoryProperties) {-# NOINLINE vkGetPhysicalDeviceMemoryPropertiesUnsafe #-} #endif -- | -- > void vkGetPhysicalDeviceMemoryProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkPhysicalDeviceMemoryProperties* pMemoryProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceMemoryProperties <- vkGetInstanceProc @VkGetPhysicalDeviceMemoryProperties vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceMemoryProperties <- vkGetProc @VkGetPhysicalDeviceMemoryProperties -- -- __Note:__ @vkGetPhysicalDeviceMemoryPropertiesUnsafe@ and @vkGetPhysicalDeviceMemoryPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceMemoryProperties@ is an alias -- of @vkGetPhysicalDeviceMemoryPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceMemoryPropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetPhysicalDeviceMemoryProperties" vkGetPhysicalDeviceMemoryPropertiesSafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkPhysicalDeviceMemoryProperties -- ^ pMemoryProperties -> IO () #else vkGetPhysicalDeviceMemoryPropertiesSafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkPhysicalDeviceMemoryProperties -- ^ pMemoryProperties -> IO () vkGetPhysicalDeviceMemoryPropertiesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetPhysicalDeviceMemoryProperties) {-# NOINLINE vkGetPhysicalDeviceMemoryPropertiesSafe #-} #endif -- | -- > void vkGetPhysicalDeviceMemoryProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkPhysicalDeviceMemoryProperties* pMemoryProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceMemoryProperties <- vkGetInstanceProc @VkGetPhysicalDeviceMemoryProperties vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceMemoryProperties <- vkGetProc @VkGetPhysicalDeviceMemoryProperties -- -- __Note:__ @vkGetPhysicalDeviceMemoryPropertiesUnsafe@ and @vkGetPhysicalDeviceMemoryPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceMemoryProperties@ is an alias -- of @vkGetPhysicalDeviceMemoryPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceMemoryPropertiesSafe@. -- vkGetPhysicalDeviceMemoryProperties :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkPhysicalDeviceMemoryProperties -- ^ pMemoryProperties -> IO () #ifdef UNSAFE_FFI_DEFAULT vkGetPhysicalDeviceMemoryProperties = vkGetPhysicalDeviceMemoryPropertiesUnsafe #else vkGetPhysicalDeviceMemoryProperties = vkGetPhysicalDeviceMemoryPropertiesSafe #endif {-# INLINE vkGetPhysicalDeviceMemoryProperties #-} -- | > void vkGetPhysicalDeviceMemoryProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkPhysicalDeviceMemoryProperties* pMemoryProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties registry at www.khronos.org> type HS_vkGetPhysicalDeviceMemoryProperties = VkPhysicalDevice -- ^ physicalDevice -> Ptr VkPhysicalDeviceMemoryProperties -- ^ pMemoryProperties -> IO () type PFN_vkGetPhysicalDeviceMemoryProperties = FunPtr HS_vkGetPhysicalDeviceMemoryProperties foreign import ccall unsafe "dynamic" unwrapVkGetPhysicalDeviceMemoryPropertiesUnsafe :: PFN_vkGetPhysicalDeviceMemoryProperties -> HS_vkGetPhysicalDeviceMemoryProperties foreign import ccall safe "dynamic" unwrapVkGetPhysicalDeviceMemoryPropertiesSafe :: PFN_vkGetPhysicalDeviceMemoryProperties -> HS_vkGetPhysicalDeviceMemoryProperties instance VulkanProc "vkGetPhysicalDeviceMemoryProperties" where type VkProcType "vkGetPhysicalDeviceMemoryProperties" = HS_vkGetPhysicalDeviceMemoryProperties vkProcSymbol = _VkGetPhysicalDeviceMemoryProperties {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetPhysicalDeviceMemoryPropertiesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetPhysicalDeviceMemoryPropertiesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetInstanceProcAddr :: CString pattern VkGetInstanceProcAddr <- (is_VkGetInstanceProcAddr -> True) where VkGetInstanceProcAddr = _VkGetInstanceProcAddr {-# INLINE _VkGetInstanceProcAddr #-} _VkGetInstanceProcAddr :: CString _VkGetInstanceProcAddr = Ptr "vkGetInstanceProcAddr\NUL"# {-# INLINE is_VkGetInstanceProcAddr #-} is_VkGetInstanceProcAddr :: CString -> Bool is_VkGetInstanceProcAddr = (EQ ==) . cmpCStrings _VkGetInstanceProcAddr type VkGetInstanceProcAddr = "vkGetInstanceProcAddr" -- | -- > PFN_vkVoidFunction vkGetInstanceProcAddr -- > ( VkInstance instance -- > , const char* pName -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetInstanceProcAddr vkGetInstanceProcAddr registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetInstanceProcAddr <- vkGetInstanceProc @VkGetInstanceProcAddr vkInstance -- -- or less efficient: -- -- > myGetInstanceProcAddr <- vkGetProc @VkGetInstanceProcAddr -- -- __Note:__ @vkGetInstanceProcAddrUnsafe@ and @vkGetInstanceProcAddrSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetInstanceProcAddr@ is an alias -- of @vkGetInstanceProcAddrUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetInstanceProcAddrSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetInstanceProcAddr" vkGetInstanceProcAddrUnsafe :: VkInstance -- ^ instance -> CString -- ^ pName -> IO PFN_vkVoidFunction #else vkGetInstanceProcAddrUnsafe :: VkInstance -- ^ instance -> CString -- ^ pName -> IO PFN_vkVoidFunction vkGetInstanceProcAddrUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetInstanceProcAddr) {-# NOINLINE vkGetInstanceProcAddrUnsafe #-} #endif -- | -- > PFN_vkVoidFunction vkGetInstanceProcAddr -- > ( VkInstance instance -- > , const char* pName -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetInstanceProcAddr vkGetInstanceProcAddr registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetInstanceProcAddr <- vkGetInstanceProc @VkGetInstanceProcAddr vkInstance -- -- or less efficient: -- -- > myGetInstanceProcAddr <- vkGetProc @VkGetInstanceProcAddr -- -- __Note:__ @vkGetInstanceProcAddrUnsafe@ and @vkGetInstanceProcAddrSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetInstanceProcAddr@ is an alias -- of @vkGetInstanceProcAddrUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetInstanceProcAddrSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetInstanceProcAddr" vkGetInstanceProcAddrSafe :: VkInstance -- ^ instance -> CString -- ^ pName -> IO PFN_vkVoidFunction #else vkGetInstanceProcAddrSafe :: VkInstance -- ^ instance -> CString -- ^ pName -> IO PFN_vkVoidFunction vkGetInstanceProcAddrSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetInstanceProcAddr) {-# NOINLINE vkGetInstanceProcAddrSafe #-} #endif -- | -- > PFN_vkVoidFunction vkGetInstanceProcAddr -- > ( VkInstance instance -- > , const char* pName -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetInstanceProcAddr vkGetInstanceProcAddr registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetInstanceProcAddr <- vkGetInstanceProc @VkGetInstanceProcAddr vkInstance -- -- or less efficient: -- -- > myGetInstanceProcAddr <- vkGetProc @VkGetInstanceProcAddr -- -- __Note:__ @vkGetInstanceProcAddrUnsafe@ and @vkGetInstanceProcAddrSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetInstanceProcAddr@ is an alias -- of @vkGetInstanceProcAddrUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetInstanceProcAddrSafe@. -- vkGetInstanceProcAddr :: VkInstance -- ^ instance -> CString -- ^ pName -> IO PFN_vkVoidFunction #ifdef UNSAFE_FFI_DEFAULT vkGetInstanceProcAddr = vkGetInstanceProcAddrUnsafe #else vkGetInstanceProcAddr = vkGetInstanceProcAddrSafe #endif {-# INLINE vkGetInstanceProcAddr #-} -- | > PFN_vkVoidFunction vkGetInstanceProcAddr -- > ( VkInstance instance -- > , const char* pName -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetInstanceProcAddr vkGetInstanceProcAddr registry at www.khronos.org> type HS_vkGetInstanceProcAddr = VkInstance -- ^ instance -> CString -- ^ pName -> IO PFN_vkVoidFunction type PFN_vkGetInstanceProcAddr = FunPtr HS_vkGetInstanceProcAddr foreign import ccall unsafe "dynamic" unwrapVkGetInstanceProcAddrUnsafe :: PFN_vkGetInstanceProcAddr -> HS_vkGetInstanceProcAddr foreign import ccall safe "dynamic" unwrapVkGetInstanceProcAddrSafe :: PFN_vkGetInstanceProcAddr -> HS_vkGetInstanceProcAddr instance VulkanProc "vkGetInstanceProcAddr" where type VkProcType "vkGetInstanceProcAddr" = HS_vkGetInstanceProcAddr vkProcSymbol = _VkGetInstanceProcAddr {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetInstanceProcAddrUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetInstanceProcAddrSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetDeviceProcAddr :: CString pattern VkGetDeviceProcAddr <- (is_VkGetDeviceProcAddr -> True) where VkGetDeviceProcAddr = _VkGetDeviceProcAddr {-# INLINE _VkGetDeviceProcAddr #-} _VkGetDeviceProcAddr :: CString _VkGetDeviceProcAddr = Ptr "vkGetDeviceProcAddr\NUL"# {-# INLINE is_VkGetDeviceProcAddr #-} is_VkGetDeviceProcAddr :: CString -> Bool is_VkGetDeviceProcAddr = (EQ ==) . cmpCStrings _VkGetDeviceProcAddr type VkGetDeviceProcAddr = "vkGetDeviceProcAddr" -- | -- > PFN_vkVoidFunction vkGetDeviceProcAddr -- > ( VkDevice device -- > , const char* pName -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceProcAddr vkGetDeviceProcAddr registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetDeviceProcAddr <- vkGetDeviceProc @VkGetDeviceProcAddr vkDevice -- -- or less efficient: -- -- > myGetDeviceProcAddr <- vkGetProc @VkGetDeviceProcAddr -- -- __Note:__ @vkGetDeviceProcAddrUnsafe@ and @vkGetDeviceProcAddrSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetDeviceProcAddr@ is an alias -- of @vkGetDeviceProcAddrUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetDeviceProcAddrSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetDeviceProcAddr" vkGetDeviceProcAddrUnsafe :: VkDevice -- ^ device -> CString -- ^ pName -> IO PFN_vkVoidFunction #else vkGetDeviceProcAddrUnsafe :: VkDevice -- ^ device -> CString -- ^ pName -> IO PFN_vkVoidFunction vkGetDeviceProcAddrUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetDeviceProcAddr) {-# NOINLINE vkGetDeviceProcAddrUnsafe #-} #endif -- | -- > PFN_vkVoidFunction vkGetDeviceProcAddr -- > ( VkDevice device -- > , const char* pName -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceProcAddr vkGetDeviceProcAddr registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetDeviceProcAddr <- vkGetDeviceProc @VkGetDeviceProcAddr vkDevice -- -- or less efficient: -- -- > myGetDeviceProcAddr <- vkGetProc @VkGetDeviceProcAddr -- -- __Note:__ @vkGetDeviceProcAddrUnsafe@ and @vkGetDeviceProcAddrSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetDeviceProcAddr@ is an alias -- of @vkGetDeviceProcAddrUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetDeviceProcAddrSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetDeviceProcAddr" vkGetDeviceProcAddrSafe :: VkDevice -- ^ device -> CString -- ^ pName -> IO PFN_vkVoidFunction #else vkGetDeviceProcAddrSafe :: VkDevice -- ^ device -> CString -- ^ pName -> IO PFN_vkVoidFunction vkGetDeviceProcAddrSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetDeviceProcAddr) {-# NOINLINE vkGetDeviceProcAddrSafe #-} #endif -- | -- > PFN_vkVoidFunction vkGetDeviceProcAddr -- > ( VkDevice device -- > , const char* pName -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceProcAddr vkGetDeviceProcAddr registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetDeviceProcAddr <- vkGetDeviceProc @VkGetDeviceProcAddr vkDevice -- -- or less efficient: -- -- > myGetDeviceProcAddr <- vkGetProc @VkGetDeviceProcAddr -- -- __Note:__ @vkGetDeviceProcAddrUnsafe@ and @vkGetDeviceProcAddrSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetDeviceProcAddr@ is an alias -- of @vkGetDeviceProcAddrUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetDeviceProcAddrSafe@. -- vkGetDeviceProcAddr :: VkDevice -- ^ device -> CString -- ^ pName -> IO PFN_vkVoidFunction #ifdef UNSAFE_FFI_DEFAULT vkGetDeviceProcAddr = vkGetDeviceProcAddrUnsafe #else vkGetDeviceProcAddr = vkGetDeviceProcAddrSafe #endif {-# INLINE vkGetDeviceProcAddr #-} -- | > PFN_vkVoidFunction vkGetDeviceProcAddr -- > ( VkDevice device -- > , const char* pName -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceProcAddr vkGetDeviceProcAddr registry at www.khronos.org> type HS_vkGetDeviceProcAddr = VkDevice -- ^ device -> CString -- ^ pName -> IO PFN_vkVoidFunction type PFN_vkGetDeviceProcAddr = FunPtr HS_vkGetDeviceProcAddr foreign import ccall unsafe "dynamic" unwrapVkGetDeviceProcAddrUnsafe :: PFN_vkGetDeviceProcAddr -> HS_vkGetDeviceProcAddr foreign import ccall safe "dynamic" unwrapVkGetDeviceProcAddrSafe :: PFN_vkGetDeviceProcAddr -> HS_vkGetDeviceProcAddr instance VulkanProc "vkGetDeviceProcAddr" where type VkProcType "vkGetDeviceProcAddr" = HS_vkGetDeviceProcAddr vkProcSymbol = _VkGetDeviceProcAddr {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetDeviceProcAddrUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetDeviceProcAddrSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreateDevice :: CString pattern VkCreateDevice <- (is_VkCreateDevice -> True) where VkCreateDevice = _VkCreateDevice {-# INLINE _VkCreateDevice #-} _VkCreateDevice :: CString _VkCreateDevice = Ptr "vkCreateDevice\NUL"# {-# INLINE is_VkCreateDevice #-} is_VkCreateDevice :: CString -> Bool is_VkCreateDevice = (EQ ==) . cmpCStrings _VkCreateDevice type VkCreateDevice = "vkCreateDevice" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INITIALIZATION_FAILED', 'VK_ERROR_EXTENSION_NOT_PRESENT', 'VK_ERROR_FEATURE_NOT_PRESENT', 'VK_ERROR_TOO_MANY_OBJECTS', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkCreateDevice -- > ( VkPhysicalDevice physicalDevice -- > , const VkDeviceCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkDevice* pDevice -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateDevice vkCreateDevice registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateDevice <- vkGetInstanceProc @VkCreateDevice vkInstance -- -- or less efficient: -- -- > myCreateDevice <- vkGetProc @VkCreateDevice -- -- __Note:__ @vkCreateDeviceUnsafe@ and @vkCreateDeviceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateDevice@ is an alias -- of @vkCreateDeviceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateDeviceSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateDevice" vkCreateDeviceUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkDeviceCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDevice -- ^ pDevice -> IO VkResult #else vkCreateDeviceUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkDeviceCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDevice -- ^ pDevice -> IO VkResult vkCreateDeviceUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateDevice) {-# NOINLINE vkCreateDeviceUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INITIALIZATION_FAILED', 'VK_ERROR_EXTENSION_NOT_PRESENT', 'VK_ERROR_FEATURE_NOT_PRESENT', 'VK_ERROR_TOO_MANY_OBJECTS', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkCreateDevice -- > ( VkPhysicalDevice physicalDevice -- > , const VkDeviceCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkDevice* pDevice -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateDevice vkCreateDevice registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateDevice <- vkGetInstanceProc @VkCreateDevice vkInstance -- -- or less efficient: -- -- > myCreateDevice <- vkGetProc @VkCreateDevice -- -- __Note:__ @vkCreateDeviceUnsafe@ and @vkCreateDeviceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateDevice@ is an alias -- of @vkCreateDeviceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateDeviceSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateDevice" vkCreateDeviceSafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkDeviceCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDevice -- ^ pDevice -> IO VkResult #else vkCreateDeviceSafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkDeviceCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDevice -- ^ pDevice -> IO VkResult vkCreateDeviceSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateDevice) {-# NOINLINE vkCreateDeviceSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INITIALIZATION_FAILED', 'VK_ERROR_EXTENSION_NOT_PRESENT', 'VK_ERROR_FEATURE_NOT_PRESENT', 'VK_ERROR_TOO_MANY_OBJECTS', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkCreateDevice -- > ( VkPhysicalDevice physicalDevice -- > , const VkDeviceCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkDevice* pDevice -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateDevice vkCreateDevice registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateDevice <- vkGetInstanceProc @VkCreateDevice vkInstance -- -- or less efficient: -- -- > myCreateDevice <- vkGetProc @VkCreateDevice -- -- __Note:__ @vkCreateDeviceUnsafe@ and @vkCreateDeviceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateDevice@ is an alias -- of @vkCreateDeviceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateDeviceSafe@. -- vkCreateDevice :: VkPhysicalDevice -- ^ physicalDevice -> Ptr VkDeviceCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDevice -- ^ pDevice -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateDevice = vkCreateDeviceUnsafe #else vkCreateDevice = vkCreateDeviceSafe #endif {-# INLINE vkCreateDevice #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INITIALIZATION_FAILED', 'VK_ERROR_EXTENSION_NOT_PRESENT', 'VK_ERROR_FEATURE_NOT_PRESENT', 'VK_ERROR_TOO_MANY_OBJECTS', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkCreateDevice -- > ( VkPhysicalDevice physicalDevice -- > , const VkDeviceCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkDevice* pDevice -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateDevice vkCreateDevice registry at www.khronos.org> type HS_vkCreateDevice = VkPhysicalDevice -- ^ physicalDevice -> Ptr VkDeviceCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDevice -- ^ pDevice -> IO VkResult type PFN_vkCreateDevice = FunPtr HS_vkCreateDevice foreign import ccall unsafe "dynamic" unwrapVkCreateDeviceUnsafe :: PFN_vkCreateDevice -> HS_vkCreateDevice foreign import ccall safe "dynamic" unwrapVkCreateDeviceSafe :: PFN_vkCreateDevice -> HS_vkCreateDevice instance VulkanProc "vkCreateDevice" where type VkProcType "vkCreateDevice" = HS_vkCreateDevice vkProcSymbol = _VkCreateDevice {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateDeviceUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateDeviceSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroyDevice :: CString pattern VkDestroyDevice <- (is_VkDestroyDevice -> True) where VkDestroyDevice = _VkDestroyDevice {-# INLINE _VkDestroyDevice #-} _VkDestroyDevice :: CString _VkDestroyDevice = Ptr "vkDestroyDevice\NUL"# {-# INLINE is_VkDestroyDevice #-} is_VkDestroyDevice :: CString -> Bool is_VkDestroyDevice = (EQ ==) . cmpCStrings _VkDestroyDevice type VkDestroyDevice = "vkDestroyDevice" -- | -- > void vkDestroyDevice -- > ( VkDevice device -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyDevice vkDestroyDevice registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyDevice <- vkGetDeviceProc @VkDestroyDevice vkDevice -- -- or less efficient: -- -- > myDestroyDevice <- vkGetProc @VkDestroyDevice -- -- __Note:__ @vkDestroyDeviceUnsafe@ and @vkDestroyDeviceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyDevice@ is an alias -- of @vkDestroyDeviceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyDeviceSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroyDevice" vkDestroyDeviceUnsafe :: VkDevice -- ^ device -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyDeviceUnsafe :: VkDevice -- ^ device -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyDeviceUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroyDevice) {-# NOINLINE vkDestroyDeviceUnsafe #-} #endif -- | -- > void vkDestroyDevice -- > ( VkDevice device -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyDevice vkDestroyDevice registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyDevice <- vkGetDeviceProc @VkDestroyDevice vkDevice -- -- or less efficient: -- -- > myDestroyDevice <- vkGetProc @VkDestroyDevice -- -- __Note:__ @vkDestroyDeviceUnsafe@ and @vkDestroyDeviceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyDevice@ is an alias -- of @vkDestroyDeviceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyDeviceSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroyDevice" vkDestroyDeviceSafe :: VkDevice -- ^ device -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyDeviceSafe :: VkDevice -- ^ device -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyDeviceSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroyDevice) {-# NOINLINE vkDestroyDeviceSafe #-} #endif -- | -- > void vkDestroyDevice -- > ( VkDevice device -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyDevice vkDestroyDevice registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyDevice <- vkGetDeviceProc @VkDestroyDevice vkDevice -- -- or less efficient: -- -- > myDestroyDevice <- vkGetProc @VkDestroyDevice -- -- __Note:__ @vkDestroyDeviceUnsafe@ and @vkDestroyDeviceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyDevice@ is an alias -- of @vkDestroyDeviceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyDeviceSafe@. -- vkDestroyDevice :: VkDevice -- ^ device -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroyDevice = vkDestroyDeviceUnsafe #else vkDestroyDevice = vkDestroyDeviceSafe #endif {-# INLINE vkDestroyDevice #-} -- | > void vkDestroyDevice -- > ( VkDevice device -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyDevice vkDestroyDevice registry at www.khronos.org> type HS_vkDestroyDevice = VkDevice -- ^ device -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroyDevice = FunPtr HS_vkDestroyDevice foreign import ccall unsafe "dynamic" unwrapVkDestroyDeviceUnsafe :: PFN_vkDestroyDevice -> HS_vkDestroyDevice foreign import ccall safe "dynamic" unwrapVkDestroyDeviceSafe :: PFN_vkDestroyDevice -> HS_vkDestroyDevice instance VulkanProc "vkDestroyDevice" where type VkProcType "vkDestroyDevice" = HS_vkDestroyDevice vkProcSymbol = _VkDestroyDevice {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroyDeviceUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroyDeviceSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkEnumerateInstanceExtensionProperties :: CString pattern VkEnumerateInstanceExtensionProperties <- (is_VkEnumerateInstanceExtensionProperties -> True) where VkEnumerateInstanceExtensionProperties = _VkEnumerateInstanceExtensionProperties {-# INLINE _VkEnumerateInstanceExtensionProperties #-} _VkEnumerateInstanceExtensionProperties :: CString _VkEnumerateInstanceExtensionProperties = Ptr "vkEnumerateInstanceExtensionProperties\NUL"# {-# INLINE is_VkEnumerateInstanceExtensionProperties #-} is_VkEnumerateInstanceExtensionProperties :: CString -> Bool is_VkEnumerateInstanceExtensionProperties = (EQ ==) . cmpCStrings _VkEnumerateInstanceExtensionProperties type VkEnumerateInstanceExtensionProperties = "vkEnumerateInstanceExtensionProperties" -- | -- Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_LAYER_NOT_PRESENT'. -- -- > VkResult vkEnumerateInstanceExtensionProperties -- > ( const char* pLayerName -- > , uint32_t* pPropertyCount -- > , VkExtensionProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myEnumerateInstanceExtensionProperties <- vkGetInstanceProc @VkEnumerateInstanceExtensionProperties VK_NULL -- -- or less efficient: -- -- > myEnumerateInstanceExtensionProperties <- vkGetProc @VkEnumerateInstanceExtensionProperties -- -- __Note:__ @vkEnumerateInstanceExtensionPropertiesUnsafe@ and @vkEnumerateInstanceExtensionPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkEnumerateInstanceExtensionProperties@ is an alias -- of @vkEnumerateInstanceExtensionPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkEnumerateInstanceExtensionPropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkEnumerateInstanceExtensionProperties" vkEnumerateInstanceExtensionPropertiesUnsafe :: CString -- ^ pLayerName -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkExtensionProperties -- ^ pProperties -> IO VkResult #else vkEnumerateInstanceExtensionPropertiesUnsafe :: CString -- ^ pLayerName -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkExtensionProperties -- ^ pProperties -> IO VkResult vkEnumerateInstanceExtensionPropertiesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkEnumerateInstanceExtensionProperties) {-# NOINLINE vkEnumerateInstanceExtensionPropertiesUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_LAYER_NOT_PRESENT'. -- -- > VkResult vkEnumerateInstanceExtensionProperties -- > ( const char* pLayerName -- > , uint32_t* pPropertyCount -- > , VkExtensionProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myEnumerateInstanceExtensionProperties <- vkGetInstanceProc @VkEnumerateInstanceExtensionProperties VK_NULL -- -- or less efficient: -- -- > myEnumerateInstanceExtensionProperties <- vkGetProc @VkEnumerateInstanceExtensionProperties -- -- __Note:__ @vkEnumerateInstanceExtensionPropertiesUnsafe@ and @vkEnumerateInstanceExtensionPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkEnumerateInstanceExtensionProperties@ is an alias -- of @vkEnumerateInstanceExtensionPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkEnumerateInstanceExtensionPropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkEnumerateInstanceExtensionProperties" vkEnumerateInstanceExtensionPropertiesSafe :: CString -- ^ pLayerName -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkExtensionProperties -- ^ pProperties -> IO VkResult #else vkEnumerateInstanceExtensionPropertiesSafe :: CString -- ^ pLayerName -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkExtensionProperties -- ^ pProperties -> IO VkResult vkEnumerateInstanceExtensionPropertiesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkEnumerateInstanceExtensionProperties) {-# NOINLINE vkEnumerateInstanceExtensionPropertiesSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_LAYER_NOT_PRESENT'. -- -- > VkResult vkEnumerateInstanceExtensionProperties -- > ( const char* pLayerName -- > , uint32_t* pPropertyCount -- > , VkExtensionProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myEnumerateInstanceExtensionProperties <- vkGetInstanceProc @VkEnumerateInstanceExtensionProperties VK_NULL -- -- or less efficient: -- -- > myEnumerateInstanceExtensionProperties <- vkGetProc @VkEnumerateInstanceExtensionProperties -- -- __Note:__ @vkEnumerateInstanceExtensionPropertiesUnsafe@ and @vkEnumerateInstanceExtensionPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkEnumerateInstanceExtensionProperties@ is an alias -- of @vkEnumerateInstanceExtensionPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkEnumerateInstanceExtensionPropertiesSafe@. -- vkEnumerateInstanceExtensionProperties :: CString -- ^ pLayerName -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkExtensionProperties -- ^ pProperties -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkEnumerateInstanceExtensionProperties = vkEnumerateInstanceExtensionPropertiesUnsafe #else vkEnumerateInstanceExtensionProperties = vkEnumerateInstanceExtensionPropertiesSafe #endif {-# INLINE vkEnumerateInstanceExtensionProperties #-} -- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_LAYER_NOT_PRESENT'. -- -- > VkResult vkEnumerateInstanceExtensionProperties -- > ( const char* pLayerName -- > , uint32_t* pPropertyCount -- > , VkExtensionProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties registry at www.khronos.org> type HS_vkEnumerateInstanceExtensionProperties = CString -- ^ pLayerName -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkExtensionProperties -- ^ pProperties -> IO VkResult type PFN_vkEnumerateInstanceExtensionProperties = FunPtr HS_vkEnumerateInstanceExtensionProperties foreign import ccall unsafe "dynamic" unwrapVkEnumerateInstanceExtensionPropertiesUnsafe :: PFN_vkEnumerateInstanceExtensionProperties -> HS_vkEnumerateInstanceExtensionProperties foreign import ccall safe "dynamic" unwrapVkEnumerateInstanceExtensionPropertiesSafe :: PFN_vkEnumerateInstanceExtensionProperties -> HS_vkEnumerateInstanceExtensionProperties instance VulkanProc "vkEnumerateInstanceExtensionProperties" where type VkProcType "vkEnumerateInstanceExtensionProperties" = HS_vkEnumerateInstanceExtensionProperties vkProcSymbol = _VkEnumerateInstanceExtensionProperties {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkEnumerateInstanceExtensionPropertiesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkEnumerateInstanceExtensionPropertiesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkEnumerateDeviceExtensionProperties :: CString pattern VkEnumerateDeviceExtensionProperties <- (is_VkEnumerateDeviceExtensionProperties -> True) where VkEnumerateDeviceExtensionProperties = _VkEnumerateDeviceExtensionProperties {-# INLINE _VkEnumerateDeviceExtensionProperties #-} _VkEnumerateDeviceExtensionProperties :: CString _VkEnumerateDeviceExtensionProperties = Ptr "vkEnumerateDeviceExtensionProperties\NUL"# {-# INLINE is_VkEnumerateDeviceExtensionProperties #-} is_VkEnumerateDeviceExtensionProperties :: CString -> Bool is_VkEnumerateDeviceExtensionProperties = (EQ ==) . cmpCStrings _VkEnumerateDeviceExtensionProperties type VkEnumerateDeviceExtensionProperties = "vkEnumerateDeviceExtensionProperties" -- | -- Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_LAYER_NOT_PRESENT'. -- -- > VkResult vkEnumerateDeviceExtensionProperties -- > ( VkPhysicalDevice physicalDevice -- > , const char* pLayerName -- > , uint32_t* pPropertyCount -- > , VkExtensionProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myEnumerateDeviceExtensionProperties <- vkGetInstanceProc @VkEnumerateDeviceExtensionProperties vkInstance -- -- or less efficient: -- -- > myEnumerateDeviceExtensionProperties <- vkGetProc @VkEnumerateDeviceExtensionProperties -- -- __Note:__ @vkEnumerateDeviceExtensionPropertiesUnsafe@ and @vkEnumerateDeviceExtensionPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkEnumerateDeviceExtensionProperties@ is an alias -- of @vkEnumerateDeviceExtensionPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkEnumerateDeviceExtensionPropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkEnumerateDeviceExtensionProperties" vkEnumerateDeviceExtensionPropertiesUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> CString -- ^ pLayerName -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkExtensionProperties -- ^ pProperties -> IO VkResult #else vkEnumerateDeviceExtensionPropertiesUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> CString -- ^ pLayerName -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkExtensionProperties -- ^ pProperties -> IO VkResult vkEnumerateDeviceExtensionPropertiesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkEnumerateDeviceExtensionProperties) {-# NOINLINE vkEnumerateDeviceExtensionPropertiesUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_LAYER_NOT_PRESENT'. -- -- > VkResult vkEnumerateDeviceExtensionProperties -- > ( VkPhysicalDevice physicalDevice -- > , const char* pLayerName -- > , uint32_t* pPropertyCount -- > , VkExtensionProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myEnumerateDeviceExtensionProperties <- vkGetInstanceProc @VkEnumerateDeviceExtensionProperties vkInstance -- -- or less efficient: -- -- > myEnumerateDeviceExtensionProperties <- vkGetProc @VkEnumerateDeviceExtensionProperties -- -- __Note:__ @vkEnumerateDeviceExtensionPropertiesUnsafe@ and @vkEnumerateDeviceExtensionPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkEnumerateDeviceExtensionProperties@ is an alias -- of @vkEnumerateDeviceExtensionPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkEnumerateDeviceExtensionPropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkEnumerateDeviceExtensionProperties" vkEnumerateDeviceExtensionPropertiesSafe :: VkPhysicalDevice -- ^ physicalDevice -> CString -- ^ pLayerName -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkExtensionProperties -- ^ pProperties -> IO VkResult #else vkEnumerateDeviceExtensionPropertiesSafe :: VkPhysicalDevice -- ^ physicalDevice -> CString -- ^ pLayerName -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkExtensionProperties -- ^ pProperties -> IO VkResult vkEnumerateDeviceExtensionPropertiesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkEnumerateDeviceExtensionProperties) {-# NOINLINE vkEnumerateDeviceExtensionPropertiesSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_LAYER_NOT_PRESENT'. -- -- > VkResult vkEnumerateDeviceExtensionProperties -- > ( VkPhysicalDevice physicalDevice -- > , const char* pLayerName -- > , uint32_t* pPropertyCount -- > , VkExtensionProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myEnumerateDeviceExtensionProperties <- vkGetInstanceProc @VkEnumerateDeviceExtensionProperties vkInstance -- -- or less efficient: -- -- > myEnumerateDeviceExtensionProperties <- vkGetProc @VkEnumerateDeviceExtensionProperties -- -- __Note:__ @vkEnumerateDeviceExtensionPropertiesUnsafe@ and @vkEnumerateDeviceExtensionPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkEnumerateDeviceExtensionProperties@ is an alias -- of @vkEnumerateDeviceExtensionPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkEnumerateDeviceExtensionPropertiesSafe@. -- vkEnumerateDeviceExtensionProperties :: VkPhysicalDevice -- ^ physicalDevice -> CString -- ^ pLayerName -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkExtensionProperties -- ^ pProperties -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkEnumerateDeviceExtensionProperties = vkEnumerateDeviceExtensionPropertiesUnsafe #else vkEnumerateDeviceExtensionProperties = vkEnumerateDeviceExtensionPropertiesSafe #endif {-# INLINE vkEnumerateDeviceExtensionProperties #-} -- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_LAYER_NOT_PRESENT'. -- -- > VkResult vkEnumerateDeviceExtensionProperties -- > ( VkPhysicalDevice physicalDevice -- > , const char* pLayerName -- > , uint32_t* pPropertyCount -- > , VkExtensionProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties registry at www.khronos.org> type HS_vkEnumerateDeviceExtensionProperties = VkPhysicalDevice -- ^ physicalDevice -> CString -- ^ pLayerName -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkExtensionProperties -- ^ pProperties -> IO VkResult type PFN_vkEnumerateDeviceExtensionProperties = FunPtr HS_vkEnumerateDeviceExtensionProperties foreign import ccall unsafe "dynamic" unwrapVkEnumerateDeviceExtensionPropertiesUnsafe :: PFN_vkEnumerateDeviceExtensionProperties -> HS_vkEnumerateDeviceExtensionProperties foreign import ccall safe "dynamic" unwrapVkEnumerateDeviceExtensionPropertiesSafe :: PFN_vkEnumerateDeviceExtensionProperties -> HS_vkEnumerateDeviceExtensionProperties instance VulkanProc "vkEnumerateDeviceExtensionProperties" where type VkProcType "vkEnumerateDeviceExtensionProperties" = HS_vkEnumerateDeviceExtensionProperties vkProcSymbol = _VkEnumerateDeviceExtensionProperties {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkEnumerateDeviceExtensionPropertiesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkEnumerateDeviceExtensionPropertiesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkEnumerateInstanceLayerProperties :: CString pattern VkEnumerateInstanceLayerProperties <- (is_VkEnumerateInstanceLayerProperties -> True) where VkEnumerateInstanceLayerProperties = _VkEnumerateInstanceLayerProperties {-# INLINE _VkEnumerateInstanceLayerProperties #-} _VkEnumerateInstanceLayerProperties :: CString _VkEnumerateInstanceLayerProperties = Ptr "vkEnumerateInstanceLayerProperties\NUL"# {-# INLINE is_VkEnumerateInstanceLayerProperties #-} is_VkEnumerateInstanceLayerProperties :: CString -> Bool is_VkEnumerateInstanceLayerProperties = (EQ ==) . cmpCStrings _VkEnumerateInstanceLayerProperties type VkEnumerateInstanceLayerProperties = "vkEnumerateInstanceLayerProperties" -- | -- Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkEnumerateInstanceLayerProperties -- > ( uint32_t* pPropertyCount -- > , VkLayerProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myEnumerateInstanceLayerProperties <- vkGetInstanceProc @VkEnumerateInstanceLayerProperties VK_NULL -- -- or less efficient: -- -- > myEnumerateInstanceLayerProperties <- vkGetProc @VkEnumerateInstanceLayerProperties -- -- __Note:__ @vkEnumerateInstanceLayerPropertiesUnsafe@ and @vkEnumerateInstanceLayerPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkEnumerateInstanceLayerProperties@ is an alias -- of @vkEnumerateInstanceLayerPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkEnumerateInstanceLayerPropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkEnumerateInstanceLayerProperties" vkEnumerateInstanceLayerPropertiesUnsafe :: Ptr Word32 -- ^ pPropertyCount -> Ptr VkLayerProperties -- ^ pProperties -> IO VkResult #else vkEnumerateInstanceLayerPropertiesUnsafe :: Ptr Word32 -- ^ pPropertyCount -> Ptr VkLayerProperties -- ^ pProperties -> IO VkResult vkEnumerateInstanceLayerPropertiesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkEnumerateInstanceLayerProperties) {-# NOINLINE vkEnumerateInstanceLayerPropertiesUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkEnumerateInstanceLayerProperties -- > ( uint32_t* pPropertyCount -- > , VkLayerProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myEnumerateInstanceLayerProperties <- vkGetInstanceProc @VkEnumerateInstanceLayerProperties VK_NULL -- -- or less efficient: -- -- > myEnumerateInstanceLayerProperties <- vkGetProc @VkEnumerateInstanceLayerProperties -- -- __Note:__ @vkEnumerateInstanceLayerPropertiesUnsafe@ and @vkEnumerateInstanceLayerPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkEnumerateInstanceLayerProperties@ is an alias -- of @vkEnumerateInstanceLayerPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkEnumerateInstanceLayerPropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkEnumerateInstanceLayerProperties" vkEnumerateInstanceLayerPropertiesSafe :: Ptr Word32 -- ^ pPropertyCount -> Ptr VkLayerProperties -- ^ pProperties -> IO VkResult #else vkEnumerateInstanceLayerPropertiesSafe :: Ptr Word32 -- ^ pPropertyCount -> Ptr VkLayerProperties -- ^ pProperties -> IO VkResult vkEnumerateInstanceLayerPropertiesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkEnumerateInstanceLayerProperties) {-# NOINLINE vkEnumerateInstanceLayerPropertiesSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkEnumerateInstanceLayerProperties -- > ( uint32_t* pPropertyCount -- > , VkLayerProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myEnumerateInstanceLayerProperties <- vkGetInstanceProc @VkEnumerateInstanceLayerProperties VK_NULL -- -- or less efficient: -- -- > myEnumerateInstanceLayerProperties <- vkGetProc @VkEnumerateInstanceLayerProperties -- -- __Note:__ @vkEnumerateInstanceLayerPropertiesUnsafe@ and @vkEnumerateInstanceLayerPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkEnumerateInstanceLayerProperties@ is an alias -- of @vkEnumerateInstanceLayerPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkEnumerateInstanceLayerPropertiesSafe@. -- vkEnumerateInstanceLayerProperties :: Ptr Word32 -- ^ pPropertyCount -> Ptr VkLayerProperties -- ^ pProperties -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkEnumerateInstanceLayerProperties = vkEnumerateInstanceLayerPropertiesUnsafe #else vkEnumerateInstanceLayerProperties = vkEnumerateInstanceLayerPropertiesSafe #endif {-# INLINE vkEnumerateInstanceLayerProperties #-} -- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkEnumerateInstanceLayerProperties -- > ( uint32_t* pPropertyCount -- > , VkLayerProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties registry at www.khronos.org> type HS_vkEnumerateInstanceLayerProperties = Ptr Word32 -- ^ pPropertyCount -> Ptr VkLayerProperties -- ^ pProperties -> IO VkResult type PFN_vkEnumerateInstanceLayerProperties = FunPtr HS_vkEnumerateInstanceLayerProperties foreign import ccall unsafe "dynamic" unwrapVkEnumerateInstanceLayerPropertiesUnsafe :: PFN_vkEnumerateInstanceLayerProperties -> HS_vkEnumerateInstanceLayerProperties foreign import ccall safe "dynamic" unwrapVkEnumerateInstanceLayerPropertiesSafe :: PFN_vkEnumerateInstanceLayerProperties -> HS_vkEnumerateInstanceLayerProperties instance VulkanProc "vkEnumerateInstanceLayerProperties" where type VkProcType "vkEnumerateInstanceLayerProperties" = HS_vkEnumerateInstanceLayerProperties vkProcSymbol = _VkEnumerateInstanceLayerProperties {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkEnumerateInstanceLayerPropertiesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkEnumerateInstanceLayerPropertiesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkEnumerateDeviceLayerProperties :: CString pattern VkEnumerateDeviceLayerProperties <- (is_VkEnumerateDeviceLayerProperties -> True) where VkEnumerateDeviceLayerProperties = _VkEnumerateDeviceLayerProperties {-# INLINE _VkEnumerateDeviceLayerProperties #-} _VkEnumerateDeviceLayerProperties :: CString _VkEnumerateDeviceLayerProperties = Ptr "vkEnumerateDeviceLayerProperties\NUL"# {-# INLINE is_VkEnumerateDeviceLayerProperties #-} is_VkEnumerateDeviceLayerProperties :: CString -> Bool is_VkEnumerateDeviceLayerProperties = (EQ ==) . cmpCStrings _VkEnumerateDeviceLayerProperties type VkEnumerateDeviceLayerProperties = "vkEnumerateDeviceLayerProperties" -- | -- Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkEnumerateDeviceLayerProperties -- > ( VkPhysicalDevice physicalDevice -- > , uint32_t* pPropertyCount -- > , VkLayerProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myEnumerateDeviceLayerProperties <- vkGetInstanceProc @VkEnumerateDeviceLayerProperties vkInstance -- -- or less efficient: -- -- > myEnumerateDeviceLayerProperties <- vkGetProc @VkEnumerateDeviceLayerProperties -- -- __Note:__ @vkEnumerateDeviceLayerPropertiesUnsafe@ and @vkEnumerateDeviceLayerPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkEnumerateDeviceLayerProperties@ is an alias -- of @vkEnumerateDeviceLayerPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkEnumerateDeviceLayerPropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkEnumerateDeviceLayerProperties" vkEnumerateDeviceLayerPropertiesUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkLayerProperties -- ^ pProperties -> IO VkResult #else vkEnumerateDeviceLayerPropertiesUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkLayerProperties -- ^ pProperties -> IO VkResult vkEnumerateDeviceLayerPropertiesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkEnumerateDeviceLayerProperties) {-# NOINLINE vkEnumerateDeviceLayerPropertiesUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkEnumerateDeviceLayerProperties -- > ( VkPhysicalDevice physicalDevice -- > , uint32_t* pPropertyCount -- > , VkLayerProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myEnumerateDeviceLayerProperties <- vkGetInstanceProc @VkEnumerateDeviceLayerProperties vkInstance -- -- or less efficient: -- -- > myEnumerateDeviceLayerProperties <- vkGetProc @VkEnumerateDeviceLayerProperties -- -- __Note:__ @vkEnumerateDeviceLayerPropertiesUnsafe@ and @vkEnumerateDeviceLayerPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkEnumerateDeviceLayerProperties@ is an alias -- of @vkEnumerateDeviceLayerPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkEnumerateDeviceLayerPropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkEnumerateDeviceLayerProperties" vkEnumerateDeviceLayerPropertiesSafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkLayerProperties -- ^ pProperties -> IO VkResult #else vkEnumerateDeviceLayerPropertiesSafe :: VkPhysicalDevice -- ^ physicalDevice -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkLayerProperties -- ^ pProperties -> IO VkResult vkEnumerateDeviceLayerPropertiesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkEnumerateDeviceLayerProperties) {-# NOINLINE vkEnumerateDeviceLayerPropertiesSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkEnumerateDeviceLayerProperties -- > ( VkPhysicalDevice physicalDevice -- > , uint32_t* pPropertyCount -- > , VkLayerProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myEnumerateDeviceLayerProperties <- vkGetInstanceProc @VkEnumerateDeviceLayerProperties vkInstance -- -- or less efficient: -- -- > myEnumerateDeviceLayerProperties <- vkGetProc @VkEnumerateDeviceLayerProperties -- -- __Note:__ @vkEnumerateDeviceLayerPropertiesUnsafe@ and @vkEnumerateDeviceLayerPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkEnumerateDeviceLayerProperties@ is an alias -- of @vkEnumerateDeviceLayerPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkEnumerateDeviceLayerPropertiesSafe@. -- vkEnumerateDeviceLayerProperties :: VkPhysicalDevice -- ^ physicalDevice -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkLayerProperties -- ^ pProperties -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkEnumerateDeviceLayerProperties = vkEnumerateDeviceLayerPropertiesUnsafe #else vkEnumerateDeviceLayerProperties = vkEnumerateDeviceLayerPropertiesSafe #endif {-# INLINE vkEnumerateDeviceLayerProperties #-} -- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkEnumerateDeviceLayerProperties -- > ( VkPhysicalDevice physicalDevice -- > , uint32_t* pPropertyCount -- > , VkLayerProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties registry at www.khronos.org> type HS_vkEnumerateDeviceLayerProperties = VkPhysicalDevice -- ^ physicalDevice -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkLayerProperties -- ^ pProperties -> IO VkResult type PFN_vkEnumerateDeviceLayerProperties = FunPtr HS_vkEnumerateDeviceLayerProperties foreign import ccall unsafe "dynamic" unwrapVkEnumerateDeviceLayerPropertiesUnsafe :: PFN_vkEnumerateDeviceLayerProperties -> HS_vkEnumerateDeviceLayerProperties foreign import ccall safe "dynamic" unwrapVkEnumerateDeviceLayerPropertiesSafe :: PFN_vkEnumerateDeviceLayerProperties -> HS_vkEnumerateDeviceLayerProperties instance VulkanProc "vkEnumerateDeviceLayerProperties" where type VkProcType "vkEnumerateDeviceLayerProperties" = HS_vkEnumerateDeviceLayerProperties vkProcSymbol = _VkEnumerateDeviceLayerProperties {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkEnumerateDeviceLayerPropertiesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkEnumerateDeviceLayerPropertiesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetDeviceQueue :: CString pattern VkGetDeviceQueue <- (is_VkGetDeviceQueue -> True) where VkGetDeviceQueue = _VkGetDeviceQueue {-# INLINE _VkGetDeviceQueue #-} _VkGetDeviceQueue :: CString _VkGetDeviceQueue = Ptr "vkGetDeviceQueue\NUL"# {-# INLINE is_VkGetDeviceQueue #-} is_VkGetDeviceQueue :: CString -> Bool is_VkGetDeviceQueue = (EQ ==) . cmpCStrings _VkGetDeviceQueue type VkGetDeviceQueue = "vkGetDeviceQueue" -- | -- > void vkGetDeviceQueue -- > ( VkDevice device -- > , uint32_t queueFamilyIndex -- > , uint32_t queueIndex -- > , VkQueue* pQueue -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceQueue vkGetDeviceQueue registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetDeviceQueue <- vkGetDeviceProc @VkGetDeviceQueue vkDevice -- -- or less efficient: -- -- > myGetDeviceQueue <- vkGetProc @VkGetDeviceQueue -- -- __Note:__ @vkGetDeviceQueueUnsafe@ and @vkGetDeviceQueueSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetDeviceQueue@ is an alias -- of @vkGetDeviceQueueUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetDeviceQueueSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetDeviceQueue" vkGetDeviceQueueUnsafe :: VkDevice -- ^ device -> Word32 -- ^ queueFamilyIndex -> Word32 -- ^ queueIndex -> Ptr VkQueue -- ^ pQueue -> IO () #else vkGetDeviceQueueUnsafe :: VkDevice -- ^ device -> Word32 -- ^ queueFamilyIndex -> Word32 -- ^ queueIndex -> Ptr VkQueue -- ^ pQueue -> IO () vkGetDeviceQueueUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetDeviceQueue) {-# NOINLINE vkGetDeviceQueueUnsafe #-} #endif -- | -- > void vkGetDeviceQueue -- > ( VkDevice device -- > , uint32_t queueFamilyIndex -- > , uint32_t queueIndex -- > , VkQueue* pQueue -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceQueue vkGetDeviceQueue registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetDeviceQueue <- vkGetDeviceProc @VkGetDeviceQueue vkDevice -- -- or less efficient: -- -- > myGetDeviceQueue <- vkGetProc @VkGetDeviceQueue -- -- __Note:__ @vkGetDeviceQueueUnsafe@ and @vkGetDeviceQueueSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetDeviceQueue@ is an alias -- of @vkGetDeviceQueueUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetDeviceQueueSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetDeviceQueue" vkGetDeviceQueueSafe :: VkDevice -- ^ device -> Word32 -- ^ queueFamilyIndex -> Word32 -- ^ queueIndex -> Ptr VkQueue -- ^ pQueue -> IO () #else vkGetDeviceQueueSafe :: VkDevice -- ^ device -> Word32 -- ^ queueFamilyIndex -> Word32 -- ^ queueIndex -> Ptr VkQueue -- ^ pQueue -> IO () vkGetDeviceQueueSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetDeviceQueue) {-# NOINLINE vkGetDeviceQueueSafe #-} #endif -- | -- > void vkGetDeviceQueue -- > ( VkDevice device -- > , uint32_t queueFamilyIndex -- > , uint32_t queueIndex -- > , VkQueue* pQueue -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceQueue vkGetDeviceQueue registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetDeviceQueue <- vkGetDeviceProc @VkGetDeviceQueue vkDevice -- -- or less efficient: -- -- > myGetDeviceQueue <- vkGetProc @VkGetDeviceQueue -- -- __Note:__ @vkGetDeviceQueueUnsafe@ and @vkGetDeviceQueueSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetDeviceQueue@ is an alias -- of @vkGetDeviceQueueUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetDeviceQueueSafe@. -- vkGetDeviceQueue :: VkDevice -- ^ device -> Word32 -- ^ queueFamilyIndex -> Word32 -- ^ queueIndex -> Ptr VkQueue -- ^ pQueue -> IO () #ifdef UNSAFE_FFI_DEFAULT vkGetDeviceQueue = vkGetDeviceQueueUnsafe #else vkGetDeviceQueue = vkGetDeviceQueueSafe #endif {-# INLINE vkGetDeviceQueue #-} -- | > void vkGetDeviceQueue -- > ( VkDevice device -- > , uint32_t queueFamilyIndex -- > , uint32_t queueIndex -- > , VkQueue* pQueue -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceQueue vkGetDeviceQueue registry at www.khronos.org> type HS_vkGetDeviceQueue = VkDevice -- ^ device -> Word32 -- ^ queueFamilyIndex -> Word32 -- ^ queueIndex -> Ptr VkQueue -- ^ pQueue -> IO () type PFN_vkGetDeviceQueue = FunPtr HS_vkGetDeviceQueue foreign import ccall unsafe "dynamic" unwrapVkGetDeviceQueueUnsafe :: PFN_vkGetDeviceQueue -> HS_vkGetDeviceQueue foreign import ccall safe "dynamic" unwrapVkGetDeviceQueueSafe :: PFN_vkGetDeviceQueue -> HS_vkGetDeviceQueue instance VulkanProc "vkGetDeviceQueue" where type VkProcType "vkGetDeviceQueue" = HS_vkGetDeviceQueue vkProcSymbol = _VkGetDeviceQueue {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetDeviceQueueUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetDeviceQueueSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkQueueSubmit :: CString pattern VkQueueSubmit <- (is_VkQueueSubmit -> True) where VkQueueSubmit = _VkQueueSubmit {-# INLINE _VkQueueSubmit #-} _VkQueueSubmit :: CString _VkQueueSubmit = Ptr "vkQueueSubmit\NUL"# {-# INLINE is_VkQueueSubmit #-} is_VkQueueSubmit :: CString -> Bool is_VkQueueSubmit = (EQ ==) . cmpCStrings _VkQueueSubmit type VkQueueSubmit = "vkQueueSubmit" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkQueueSubmit -- > ( VkQueue queue -- > , uint32_t submitCount -- > , const VkSubmitInfo* pSubmits -- > , VkFence fence -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkQueueSubmit vkQueueSubmit registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myQueueSubmit <- vkGetInstanceProc @VkQueueSubmit vkInstance -- -- or less efficient: -- -- > myQueueSubmit <- vkGetProc @VkQueueSubmit -- -- __Note:__ @vkQueueSubmitUnsafe@ and @vkQueueSubmitSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkQueueSubmit@ is an alias -- of @vkQueueSubmitUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkQueueSubmitSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkQueueSubmit" vkQueueSubmitUnsafe :: VkQueue -- ^ queue -> Word32 -- ^ submitCount -> Ptr VkSubmitInfo -- ^ pSubmits -> VkFence -- ^ fence -> IO VkResult #else vkQueueSubmitUnsafe :: VkQueue -- ^ queue -> Word32 -- ^ submitCount -> Ptr VkSubmitInfo -- ^ pSubmits -> VkFence -- ^ fence -> IO VkResult vkQueueSubmitUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkQueueSubmit) {-# NOINLINE vkQueueSubmitUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkQueueSubmit -- > ( VkQueue queue -- > , uint32_t submitCount -- > , const VkSubmitInfo* pSubmits -- > , VkFence fence -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkQueueSubmit vkQueueSubmit registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myQueueSubmit <- vkGetInstanceProc @VkQueueSubmit vkInstance -- -- or less efficient: -- -- > myQueueSubmit <- vkGetProc @VkQueueSubmit -- -- __Note:__ @vkQueueSubmitUnsafe@ and @vkQueueSubmitSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkQueueSubmit@ is an alias -- of @vkQueueSubmitUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkQueueSubmitSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkQueueSubmit" vkQueueSubmitSafe :: VkQueue -- ^ queue -> Word32 -- ^ submitCount -> Ptr VkSubmitInfo -- ^ pSubmits -> VkFence -- ^ fence -> IO VkResult #else vkQueueSubmitSafe :: VkQueue -- ^ queue -> Word32 -- ^ submitCount -> Ptr VkSubmitInfo -- ^ pSubmits -> VkFence -- ^ fence -> IO VkResult vkQueueSubmitSafe = unsafeDupablePerformIO (vkGetProcSafe @VkQueueSubmit) {-# NOINLINE vkQueueSubmitSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkQueueSubmit -- > ( VkQueue queue -- > , uint32_t submitCount -- > , const VkSubmitInfo* pSubmits -- > , VkFence fence -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkQueueSubmit vkQueueSubmit registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myQueueSubmit <- vkGetInstanceProc @VkQueueSubmit vkInstance -- -- or less efficient: -- -- > myQueueSubmit <- vkGetProc @VkQueueSubmit -- -- __Note:__ @vkQueueSubmitUnsafe@ and @vkQueueSubmitSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkQueueSubmit@ is an alias -- of @vkQueueSubmitUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkQueueSubmitSafe@. -- vkQueueSubmit :: VkQueue -- ^ queue -> Word32 -- ^ submitCount -> Ptr VkSubmitInfo -- ^ pSubmits -> VkFence -- ^ fence -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkQueueSubmit = vkQueueSubmitUnsafe #else vkQueueSubmit = vkQueueSubmitSafe #endif {-# INLINE vkQueueSubmit #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkQueueSubmit -- > ( VkQueue queue -- > , uint32_t submitCount -- > , const VkSubmitInfo* pSubmits -- > , VkFence fence -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkQueueSubmit vkQueueSubmit registry at www.khronos.org> type HS_vkQueueSubmit = VkQueue -- ^ queue -> Word32 -- ^ submitCount -> Ptr VkSubmitInfo -- ^ pSubmits -> VkFence -- ^ fence -> IO VkResult type PFN_vkQueueSubmit = FunPtr HS_vkQueueSubmit foreign import ccall unsafe "dynamic" unwrapVkQueueSubmitUnsafe :: PFN_vkQueueSubmit -> HS_vkQueueSubmit foreign import ccall safe "dynamic" unwrapVkQueueSubmitSafe :: PFN_vkQueueSubmit -> HS_vkQueueSubmit instance VulkanProc "vkQueueSubmit" where type VkProcType "vkQueueSubmit" = HS_vkQueueSubmit vkProcSymbol = _VkQueueSubmit {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkQueueSubmitUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkQueueSubmitSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkQueueWaitIdle :: CString pattern VkQueueWaitIdle <- (is_VkQueueWaitIdle -> True) where VkQueueWaitIdle = _VkQueueWaitIdle {-# INLINE _VkQueueWaitIdle #-} _VkQueueWaitIdle :: CString _VkQueueWaitIdle = Ptr "vkQueueWaitIdle\NUL"# {-# INLINE is_VkQueueWaitIdle #-} is_VkQueueWaitIdle :: CString -> Bool is_VkQueueWaitIdle = (EQ ==) . cmpCStrings _VkQueueWaitIdle type VkQueueWaitIdle = "vkQueueWaitIdle" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkQueueWaitIdle -- > ( VkQueue queue -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkQueueWaitIdle vkQueueWaitIdle registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myQueueWaitIdle <- vkGetInstanceProc @VkQueueWaitIdle vkInstance -- -- or less efficient: -- -- > myQueueWaitIdle <- vkGetProc @VkQueueWaitIdle -- -- __Note:__ @vkQueueWaitIdleUnsafe@ and @vkQueueWaitIdleSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkQueueWaitIdle@ is an alias -- of @vkQueueWaitIdleUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkQueueWaitIdleSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkQueueWaitIdle" vkQueueWaitIdleUnsafe :: VkQueue -- ^ queue -> IO VkResult #else vkQueueWaitIdleUnsafe :: VkQueue -- ^ queue -> IO VkResult vkQueueWaitIdleUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkQueueWaitIdle) {-# NOINLINE vkQueueWaitIdleUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkQueueWaitIdle -- > ( VkQueue queue -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkQueueWaitIdle vkQueueWaitIdle registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myQueueWaitIdle <- vkGetInstanceProc @VkQueueWaitIdle vkInstance -- -- or less efficient: -- -- > myQueueWaitIdle <- vkGetProc @VkQueueWaitIdle -- -- __Note:__ @vkQueueWaitIdleUnsafe@ and @vkQueueWaitIdleSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkQueueWaitIdle@ is an alias -- of @vkQueueWaitIdleUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkQueueWaitIdleSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkQueueWaitIdle" vkQueueWaitIdleSafe :: VkQueue -- ^ queue -> IO VkResult #else vkQueueWaitIdleSafe :: VkQueue -- ^ queue -> IO VkResult vkQueueWaitIdleSafe = unsafeDupablePerformIO (vkGetProcSafe @VkQueueWaitIdle) {-# NOINLINE vkQueueWaitIdleSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkQueueWaitIdle -- > ( VkQueue queue -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkQueueWaitIdle vkQueueWaitIdle registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myQueueWaitIdle <- vkGetInstanceProc @VkQueueWaitIdle vkInstance -- -- or less efficient: -- -- > myQueueWaitIdle <- vkGetProc @VkQueueWaitIdle -- -- __Note:__ @vkQueueWaitIdleUnsafe@ and @vkQueueWaitIdleSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkQueueWaitIdle@ is an alias -- of @vkQueueWaitIdleUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkQueueWaitIdleSafe@. -- vkQueueWaitIdle :: VkQueue -- ^ queue -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkQueueWaitIdle = vkQueueWaitIdleUnsafe #else vkQueueWaitIdle = vkQueueWaitIdleSafe #endif {-# INLINE vkQueueWaitIdle #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkQueueWaitIdle -- > ( VkQueue queue -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkQueueWaitIdle vkQueueWaitIdle registry at www.khronos.org> type HS_vkQueueWaitIdle = VkQueue -- ^ queue -> IO VkResult type PFN_vkQueueWaitIdle = FunPtr HS_vkQueueWaitIdle foreign import ccall unsafe "dynamic" unwrapVkQueueWaitIdleUnsafe :: PFN_vkQueueWaitIdle -> HS_vkQueueWaitIdle foreign import ccall safe "dynamic" unwrapVkQueueWaitIdleSafe :: PFN_vkQueueWaitIdle -> HS_vkQueueWaitIdle instance VulkanProc "vkQueueWaitIdle" where type VkProcType "vkQueueWaitIdle" = HS_vkQueueWaitIdle vkProcSymbol = _VkQueueWaitIdle {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkQueueWaitIdleUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkQueueWaitIdleSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDeviceWaitIdle :: CString pattern VkDeviceWaitIdle <- (is_VkDeviceWaitIdle -> True) where VkDeviceWaitIdle = _VkDeviceWaitIdle {-# INLINE _VkDeviceWaitIdle #-} _VkDeviceWaitIdle :: CString _VkDeviceWaitIdle = Ptr "vkDeviceWaitIdle\NUL"# {-# INLINE is_VkDeviceWaitIdle #-} is_VkDeviceWaitIdle :: CString -> Bool is_VkDeviceWaitIdle = (EQ ==) . cmpCStrings _VkDeviceWaitIdle type VkDeviceWaitIdle = "vkDeviceWaitIdle" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkDeviceWaitIdle -- > ( VkDevice device -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDeviceWaitIdle vkDeviceWaitIdle registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDeviceWaitIdle <- vkGetDeviceProc @VkDeviceWaitIdle vkDevice -- -- or less efficient: -- -- > myDeviceWaitIdle <- vkGetProc @VkDeviceWaitIdle -- -- __Note:__ @vkDeviceWaitIdleUnsafe@ and @vkDeviceWaitIdleSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDeviceWaitIdle@ is an alias -- of @vkDeviceWaitIdleUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDeviceWaitIdleSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDeviceWaitIdle" vkDeviceWaitIdleUnsafe :: VkDevice -- ^ device -> IO VkResult #else vkDeviceWaitIdleUnsafe :: VkDevice -- ^ device -> IO VkResult vkDeviceWaitIdleUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDeviceWaitIdle) {-# NOINLINE vkDeviceWaitIdleUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkDeviceWaitIdle -- > ( VkDevice device -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDeviceWaitIdle vkDeviceWaitIdle registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDeviceWaitIdle <- vkGetDeviceProc @VkDeviceWaitIdle vkDevice -- -- or less efficient: -- -- > myDeviceWaitIdle <- vkGetProc @VkDeviceWaitIdle -- -- __Note:__ @vkDeviceWaitIdleUnsafe@ and @vkDeviceWaitIdleSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDeviceWaitIdle@ is an alias -- of @vkDeviceWaitIdleUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDeviceWaitIdleSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDeviceWaitIdle" vkDeviceWaitIdleSafe :: VkDevice -- ^ device -> IO VkResult #else vkDeviceWaitIdleSafe :: VkDevice -- ^ device -> IO VkResult vkDeviceWaitIdleSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDeviceWaitIdle) {-# NOINLINE vkDeviceWaitIdleSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkDeviceWaitIdle -- > ( VkDevice device -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDeviceWaitIdle vkDeviceWaitIdle registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDeviceWaitIdle <- vkGetDeviceProc @VkDeviceWaitIdle vkDevice -- -- or less efficient: -- -- > myDeviceWaitIdle <- vkGetProc @VkDeviceWaitIdle -- -- __Note:__ @vkDeviceWaitIdleUnsafe@ and @vkDeviceWaitIdleSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDeviceWaitIdle@ is an alias -- of @vkDeviceWaitIdleUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDeviceWaitIdleSafe@. -- vkDeviceWaitIdle :: VkDevice -- ^ device -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkDeviceWaitIdle = vkDeviceWaitIdleUnsafe #else vkDeviceWaitIdle = vkDeviceWaitIdleSafe #endif {-# INLINE vkDeviceWaitIdle #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkDeviceWaitIdle -- > ( VkDevice device -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDeviceWaitIdle vkDeviceWaitIdle registry at www.khronos.org> type HS_vkDeviceWaitIdle = VkDevice -- ^ device -> IO VkResult type PFN_vkDeviceWaitIdle = FunPtr HS_vkDeviceWaitIdle foreign import ccall unsafe "dynamic" unwrapVkDeviceWaitIdleUnsafe :: PFN_vkDeviceWaitIdle -> HS_vkDeviceWaitIdle foreign import ccall safe "dynamic" unwrapVkDeviceWaitIdleSafe :: PFN_vkDeviceWaitIdle -> HS_vkDeviceWaitIdle instance VulkanProc "vkDeviceWaitIdle" where type VkProcType "vkDeviceWaitIdle" = HS_vkDeviceWaitIdle vkProcSymbol = _VkDeviceWaitIdle {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDeviceWaitIdleUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDeviceWaitIdleSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkAllocateMemory :: CString pattern VkAllocateMemory <- (is_VkAllocateMemory -> True) where VkAllocateMemory = _VkAllocateMemory {-# INLINE _VkAllocateMemory #-} _VkAllocateMemory :: CString _VkAllocateMemory = Ptr "vkAllocateMemory\NUL"# {-# INLINE is_VkAllocateMemory #-} is_VkAllocateMemory :: CString -> Bool is_VkAllocateMemory = (EQ ==) . cmpCStrings _VkAllocateMemory type VkAllocateMemory = "vkAllocateMemory" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_EXTERNAL_HANDLE', 'VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR'. -- -- > VkResult vkAllocateMemory -- > ( VkDevice device -- > , const VkMemoryAllocateInfo* pAllocateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkDeviceMemory* pMemory -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkAllocateMemory vkAllocateMemory registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myAllocateMemory <- vkGetDeviceProc @VkAllocateMemory vkDevice -- -- or less efficient: -- -- > myAllocateMemory <- vkGetProc @VkAllocateMemory -- -- __Note:__ @vkAllocateMemoryUnsafe@ and @vkAllocateMemorySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkAllocateMemory@ is an alias -- of @vkAllocateMemoryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkAllocateMemorySafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkAllocateMemory" vkAllocateMemoryUnsafe :: VkDevice -- ^ device -> Ptr VkMemoryAllocateInfo -- ^ pAllocateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDeviceMemory -- ^ pMemory -> IO VkResult #else vkAllocateMemoryUnsafe :: VkDevice -- ^ device -> Ptr VkMemoryAllocateInfo -- ^ pAllocateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDeviceMemory -- ^ pMemory -> IO VkResult vkAllocateMemoryUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkAllocateMemory) {-# NOINLINE vkAllocateMemoryUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_EXTERNAL_HANDLE', 'VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR'. -- -- > VkResult vkAllocateMemory -- > ( VkDevice device -- > , const VkMemoryAllocateInfo* pAllocateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkDeviceMemory* pMemory -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkAllocateMemory vkAllocateMemory registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myAllocateMemory <- vkGetDeviceProc @VkAllocateMemory vkDevice -- -- or less efficient: -- -- > myAllocateMemory <- vkGetProc @VkAllocateMemory -- -- __Note:__ @vkAllocateMemoryUnsafe@ and @vkAllocateMemorySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkAllocateMemory@ is an alias -- of @vkAllocateMemoryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkAllocateMemorySafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkAllocateMemory" vkAllocateMemorySafe :: VkDevice -- ^ device -> Ptr VkMemoryAllocateInfo -- ^ pAllocateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDeviceMemory -- ^ pMemory -> IO VkResult #else vkAllocateMemorySafe :: VkDevice -- ^ device -> Ptr VkMemoryAllocateInfo -- ^ pAllocateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDeviceMemory -- ^ pMemory -> IO VkResult vkAllocateMemorySafe = unsafeDupablePerformIO (vkGetProcSafe @VkAllocateMemory) {-# NOINLINE vkAllocateMemorySafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_EXTERNAL_HANDLE', 'VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR'. -- -- > VkResult vkAllocateMemory -- > ( VkDevice device -- > , const VkMemoryAllocateInfo* pAllocateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkDeviceMemory* pMemory -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkAllocateMemory vkAllocateMemory registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myAllocateMemory <- vkGetDeviceProc @VkAllocateMemory vkDevice -- -- or less efficient: -- -- > myAllocateMemory <- vkGetProc @VkAllocateMemory -- -- __Note:__ @vkAllocateMemoryUnsafe@ and @vkAllocateMemorySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkAllocateMemory@ is an alias -- of @vkAllocateMemoryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkAllocateMemorySafe@. -- vkAllocateMemory :: VkDevice -- ^ device -> Ptr VkMemoryAllocateInfo -- ^ pAllocateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDeviceMemory -- ^ pMemory -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkAllocateMemory = vkAllocateMemoryUnsafe #else vkAllocateMemory = vkAllocateMemorySafe #endif {-# INLINE vkAllocateMemory #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_EXTERNAL_HANDLE', 'VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR'. -- -- > VkResult vkAllocateMemory -- > ( VkDevice device -- > , const VkMemoryAllocateInfo* pAllocateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkDeviceMemory* pMemory -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkAllocateMemory vkAllocateMemory registry at www.khronos.org> type HS_vkAllocateMemory = VkDevice -- ^ device -> Ptr VkMemoryAllocateInfo -- ^ pAllocateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDeviceMemory -- ^ pMemory -> IO VkResult type PFN_vkAllocateMemory = FunPtr HS_vkAllocateMemory foreign import ccall unsafe "dynamic" unwrapVkAllocateMemoryUnsafe :: PFN_vkAllocateMemory -> HS_vkAllocateMemory foreign import ccall safe "dynamic" unwrapVkAllocateMemorySafe :: PFN_vkAllocateMemory -> HS_vkAllocateMemory instance VulkanProc "vkAllocateMemory" where type VkProcType "vkAllocateMemory" = HS_vkAllocateMemory vkProcSymbol = _VkAllocateMemory {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkAllocateMemoryUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkAllocateMemorySafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkFreeMemory :: CString pattern VkFreeMemory <- (is_VkFreeMemory -> True) where VkFreeMemory = _VkFreeMemory {-# INLINE _VkFreeMemory #-} _VkFreeMemory :: CString _VkFreeMemory = Ptr "vkFreeMemory\NUL"# {-# INLINE is_VkFreeMemory #-} is_VkFreeMemory :: CString -> Bool is_VkFreeMemory = (EQ ==) . cmpCStrings _VkFreeMemory type VkFreeMemory = "vkFreeMemory" -- | -- > void vkFreeMemory -- > ( VkDevice device -- > , VkDeviceMemory memory -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkFreeMemory vkFreeMemory registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myFreeMemory <- vkGetDeviceProc @VkFreeMemory vkDevice -- -- or less efficient: -- -- > myFreeMemory <- vkGetProc @VkFreeMemory -- -- __Note:__ @vkFreeMemoryUnsafe@ and @vkFreeMemorySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkFreeMemory@ is an alias -- of @vkFreeMemoryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkFreeMemorySafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkFreeMemory" vkFreeMemoryUnsafe :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkFreeMemoryUnsafe :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkFreeMemoryUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkFreeMemory) {-# NOINLINE vkFreeMemoryUnsafe #-} #endif -- | -- > void vkFreeMemory -- > ( VkDevice device -- > , VkDeviceMemory memory -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkFreeMemory vkFreeMemory registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myFreeMemory <- vkGetDeviceProc @VkFreeMemory vkDevice -- -- or less efficient: -- -- > myFreeMemory <- vkGetProc @VkFreeMemory -- -- __Note:__ @vkFreeMemoryUnsafe@ and @vkFreeMemorySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkFreeMemory@ is an alias -- of @vkFreeMemoryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkFreeMemorySafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkFreeMemory" vkFreeMemorySafe :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkFreeMemorySafe :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkFreeMemorySafe = unsafeDupablePerformIO (vkGetProcSafe @VkFreeMemory) {-# NOINLINE vkFreeMemorySafe #-} #endif -- | -- > void vkFreeMemory -- > ( VkDevice device -- > , VkDeviceMemory memory -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkFreeMemory vkFreeMemory registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myFreeMemory <- vkGetDeviceProc @VkFreeMemory vkDevice -- -- or less efficient: -- -- > myFreeMemory <- vkGetProc @VkFreeMemory -- -- __Note:__ @vkFreeMemoryUnsafe@ and @vkFreeMemorySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkFreeMemory@ is an alias -- of @vkFreeMemoryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkFreeMemorySafe@. -- vkFreeMemory :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkFreeMemory = vkFreeMemoryUnsafe #else vkFreeMemory = vkFreeMemorySafe #endif {-# INLINE vkFreeMemory #-} -- | > void vkFreeMemory -- > ( VkDevice device -- > , VkDeviceMemory memory -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkFreeMemory vkFreeMemory registry at www.khronos.org> type HS_vkFreeMemory = VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkFreeMemory = FunPtr HS_vkFreeMemory foreign import ccall unsafe "dynamic" unwrapVkFreeMemoryUnsafe :: PFN_vkFreeMemory -> HS_vkFreeMemory foreign import ccall safe "dynamic" unwrapVkFreeMemorySafe :: PFN_vkFreeMemory -> HS_vkFreeMemory instance VulkanProc "vkFreeMemory" where type VkProcType "vkFreeMemory" = HS_vkFreeMemory vkProcSymbol = _VkFreeMemory {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkFreeMemoryUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkFreeMemorySafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkMapMemory :: CString pattern VkMapMemory <- (is_VkMapMemory -> True) where VkMapMemory = _VkMapMemory {-# INLINE _VkMapMemory #-} _VkMapMemory :: CString _VkMapMemory = Ptr "vkMapMemory\NUL"# {-# INLINE is_VkMapMemory #-} is_VkMapMemory :: CString -> Bool is_VkMapMemory = (EQ ==) . cmpCStrings _VkMapMemory type VkMapMemory = "vkMapMemory" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_MEMORY_MAP_FAILED'. -- -- > VkResult vkMapMemory -- > ( VkDevice device -- > , VkDeviceMemory memory -- > , VkDeviceSize offset -- > , VkDeviceSize size -- > , VkMemoryMapFlags flags -- > , void** ppData -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkMapMemory vkMapMemory registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myMapMemory <- vkGetDeviceProc @VkMapMemory vkDevice -- -- or less efficient: -- -- > myMapMemory <- vkGetProc @VkMapMemory -- -- __Note:__ @vkMapMemoryUnsafe@ and @vkMapMemorySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkMapMemory@ is an alias -- of @vkMapMemoryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkMapMemorySafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkMapMemory" vkMapMemoryUnsafe :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> VkDeviceSize -- ^ offset -> VkDeviceSize -- ^ size -> VkMemoryMapFlags -- ^ flags -> Ptr (Ptr Void) -- ^ ppData -> IO VkResult #else vkMapMemoryUnsafe :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> VkDeviceSize -- ^ offset -> VkDeviceSize -- ^ size -> VkMemoryMapFlags -- ^ flags -> Ptr (Ptr Void) -- ^ ppData -> IO VkResult vkMapMemoryUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkMapMemory) {-# NOINLINE vkMapMemoryUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_MEMORY_MAP_FAILED'. -- -- > VkResult vkMapMemory -- > ( VkDevice device -- > , VkDeviceMemory memory -- > , VkDeviceSize offset -- > , VkDeviceSize size -- > , VkMemoryMapFlags flags -- > , void** ppData -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkMapMemory vkMapMemory registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myMapMemory <- vkGetDeviceProc @VkMapMemory vkDevice -- -- or less efficient: -- -- > myMapMemory <- vkGetProc @VkMapMemory -- -- __Note:__ @vkMapMemoryUnsafe@ and @vkMapMemorySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkMapMemory@ is an alias -- of @vkMapMemoryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkMapMemorySafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkMapMemory" vkMapMemorySafe :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> VkDeviceSize -- ^ offset -> VkDeviceSize -- ^ size -> VkMemoryMapFlags -- ^ flags -> Ptr (Ptr Void) -- ^ ppData -> IO VkResult #else vkMapMemorySafe :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> VkDeviceSize -- ^ offset -> VkDeviceSize -- ^ size -> VkMemoryMapFlags -- ^ flags -> Ptr (Ptr Void) -- ^ ppData -> IO VkResult vkMapMemorySafe = unsafeDupablePerformIO (vkGetProcSafe @VkMapMemory) {-# NOINLINE vkMapMemorySafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_MEMORY_MAP_FAILED'. -- -- > VkResult vkMapMemory -- > ( VkDevice device -- > , VkDeviceMemory memory -- > , VkDeviceSize offset -- > , VkDeviceSize size -- > , VkMemoryMapFlags flags -- > , void** ppData -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkMapMemory vkMapMemory registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myMapMemory <- vkGetDeviceProc @VkMapMemory vkDevice -- -- or less efficient: -- -- > myMapMemory <- vkGetProc @VkMapMemory -- -- __Note:__ @vkMapMemoryUnsafe@ and @vkMapMemorySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkMapMemory@ is an alias -- of @vkMapMemoryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkMapMemorySafe@. -- vkMapMemory :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> VkDeviceSize -- ^ offset -> VkDeviceSize -- ^ size -> VkMemoryMapFlags -- ^ flags -> Ptr (Ptr Void) -- ^ ppData -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkMapMemory = vkMapMemoryUnsafe #else vkMapMemory = vkMapMemorySafe #endif {-# INLINE vkMapMemory #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_MEMORY_MAP_FAILED'. -- -- > VkResult vkMapMemory -- > ( VkDevice device -- > , VkDeviceMemory memory -- > , VkDeviceSize offset -- > , VkDeviceSize size -- > , VkMemoryMapFlags flags -- > , void** ppData -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkMapMemory vkMapMemory registry at www.khronos.org> type HS_vkMapMemory = VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> VkDeviceSize -- ^ offset -> VkDeviceSize -- ^ size -> VkMemoryMapFlags -- ^ flags -> Ptr (Ptr Void) -- ^ ppData -> IO VkResult type PFN_vkMapMemory = FunPtr HS_vkMapMemory foreign import ccall unsafe "dynamic" unwrapVkMapMemoryUnsafe :: PFN_vkMapMemory -> HS_vkMapMemory foreign import ccall safe "dynamic" unwrapVkMapMemorySafe :: PFN_vkMapMemory -> HS_vkMapMemory instance VulkanProc "vkMapMemory" where type VkProcType "vkMapMemory" = HS_vkMapMemory vkProcSymbol = _VkMapMemory {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkMapMemoryUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkMapMemorySafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkUnmapMemory :: CString pattern VkUnmapMemory <- (is_VkUnmapMemory -> True) where VkUnmapMemory = _VkUnmapMemory {-# INLINE _VkUnmapMemory #-} _VkUnmapMemory :: CString _VkUnmapMemory = Ptr "vkUnmapMemory\NUL"# {-# INLINE is_VkUnmapMemory #-} is_VkUnmapMemory :: CString -> Bool is_VkUnmapMemory = (EQ ==) . cmpCStrings _VkUnmapMemory type VkUnmapMemory = "vkUnmapMemory" -- | -- > void vkUnmapMemory -- > ( VkDevice device -- > , VkDeviceMemory memory -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkUnmapMemory vkUnmapMemory registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myUnmapMemory <- vkGetDeviceProc @VkUnmapMemory vkDevice -- -- or less efficient: -- -- > myUnmapMemory <- vkGetProc @VkUnmapMemory -- -- __Note:__ @vkUnmapMemoryUnsafe@ and @vkUnmapMemorySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkUnmapMemory@ is an alias -- of @vkUnmapMemoryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkUnmapMemorySafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkUnmapMemory" vkUnmapMemoryUnsafe :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> IO () #else vkUnmapMemoryUnsafe :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> IO () vkUnmapMemoryUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkUnmapMemory) {-# NOINLINE vkUnmapMemoryUnsafe #-} #endif -- | -- > void vkUnmapMemory -- > ( VkDevice device -- > , VkDeviceMemory memory -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkUnmapMemory vkUnmapMemory registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myUnmapMemory <- vkGetDeviceProc @VkUnmapMemory vkDevice -- -- or less efficient: -- -- > myUnmapMemory <- vkGetProc @VkUnmapMemory -- -- __Note:__ @vkUnmapMemoryUnsafe@ and @vkUnmapMemorySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkUnmapMemory@ is an alias -- of @vkUnmapMemoryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkUnmapMemorySafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkUnmapMemory" vkUnmapMemorySafe :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> IO () #else vkUnmapMemorySafe :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> IO () vkUnmapMemorySafe = unsafeDupablePerformIO (vkGetProcSafe @VkUnmapMemory) {-# NOINLINE vkUnmapMemorySafe #-} #endif -- | -- > void vkUnmapMemory -- > ( VkDevice device -- > , VkDeviceMemory memory -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkUnmapMemory vkUnmapMemory registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myUnmapMemory <- vkGetDeviceProc @VkUnmapMemory vkDevice -- -- or less efficient: -- -- > myUnmapMemory <- vkGetProc @VkUnmapMemory -- -- __Note:__ @vkUnmapMemoryUnsafe@ and @vkUnmapMemorySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkUnmapMemory@ is an alias -- of @vkUnmapMemoryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkUnmapMemorySafe@. -- vkUnmapMemory :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> IO () #ifdef UNSAFE_FFI_DEFAULT vkUnmapMemory = vkUnmapMemoryUnsafe #else vkUnmapMemory = vkUnmapMemorySafe #endif {-# INLINE vkUnmapMemory #-} -- | > void vkUnmapMemory -- > ( VkDevice device -- > , VkDeviceMemory memory -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkUnmapMemory vkUnmapMemory registry at www.khronos.org> type HS_vkUnmapMemory = VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> IO () type PFN_vkUnmapMemory = FunPtr HS_vkUnmapMemory foreign import ccall unsafe "dynamic" unwrapVkUnmapMemoryUnsafe :: PFN_vkUnmapMemory -> HS_vkUnmapMemory foreign import ccall safe "dynamic" unwrapVkUnmapMemorySafe :: PFN_vkUnmapMemory -> HS_vkUnmapMemory instance VulkanProc "vkUnmapMemory" where type VkProcType "vkUnmapMemory" = HS_vkUnmapMemory vkProcSymbol = _VkUnmapMemory {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkUnmapMemoryUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkUnmapMemorySafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkFlushMappedMemoryRanges :: CString pattern VkFlushMappedMemoryRanges <- (is_VkFlushMappedMemoryRanges -> True) where VkFlushMappedMemoryRanges = _VkFlushMappedMemoryRanges {-# INLINE _VkFlushMappedMemoryRanges #-} _VkFlushMappedMemoryRanges :: CString _VkFlushMappedMemoryRanges = Ptr "vkFlushMappedMemoryRanges\NUL"# {-# INLINE is_VkFlushMappedMemoryRanges #-} is_VkFlushMappedMemoryRanges :: CString -> Bool is_VkFlushMappedMemoryRanges = (EQ ==) . cmpCStrings _VkFlushMappedMemoryRanges type VkFlushMappedMemoryRanges = "vkFlushMappedMemoryRanges" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkFlushMappedMemoryRanges -- > ( VkDevice device -- > , uint32_t memoryRangeCount -- > , const VkMappedMemoryRange* pMemoryRanges -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myFlushMappedMemoryRanges <- vkGetDeviceProc @VkFlushMappedMemoryRanges vkDevice -- -- or less efficient: -- -- > myFlushMappedMemoryRanges <- vkGetProc @VkFlushMappedMemoryRanges -- -- __Note:__ @vkFlushMappedMemoryRangesUnsafe@ and @vkFlushMappedMemoryRangesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkFlushMappedMemoryRanges@ is an alias -- of @vkFlushMappedMemoryRangesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkFlushMappedMemoryRangesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkFlushMappedMemoryRanges" vkFlushMappedMemoryRangesUnsafe :: VkDevice -- ^ device -> Word32 -- ^ memoryRangeCount -> Ptr VkMappedMemoryRange -- ^ pMemoryRanges -> IO VkResult #else vkFlushMappedMemoryRangesUnsafe :: VkDevice -- ^ device -> Word32 -- ^ memoryRangeCount -> Ptr VkMappedMemoryRange -- ^ pMemoryRanges -> IO VkResult vkFlushMappedMemoryRangesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkFlushMappedMemoryRanges) {-# NOINLINE vkFlushMappedMemoryRangesUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkFlushMappedMemoryRanges -- > ( VkDevice device -- > , uint32_t memoryRangeCount -- > , const VkMappedMemoryRange* pMemoryRanges -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myFlushMappedMemoryRanges <- vkGetDeviceProc @VkFlushMappedMemoryRanges vkDevice -- -- or less efficient: -- -- > myFlushMappedMemoryRanges <- vkGetProc @VkFlushMappedMemoryRanges -- -- __Note:__ @vkFlushMappedMemoryRangesUnsafe@ and @vkFlushMappedMemoryRangesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkFlushMappedMemoryRanges@ is an alias -- of @vkFlushMappedMemoryRangesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkFlushMappedMemoryRangesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkFlushMappedMemoryRanges" vkFlushMappedMemoryRangesSafe :: VkDevice -- ^ device -> Word32 -- ^ memoryRangeCount -> Ptr VkMappedMemoryRange -- ^ pMemoryRanges -> IO VkResult #else vkFlushMappedMemoryRangesSafe :: VkDevice -- ^ device -> Word32 -- ^ memoryRangeCount -> Ptr VkMappedMemoryRange -- ^ pMemoryRanges -> IO VkResult vkFlushMappedMemoryRangesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkFlushMappedMemoryRanges) {-# NOINLINE vkFlushMappedMemoryRangesSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkFlushMappedMemoryRanges -- > ( VkDevice device -- > , uint32_t memoryRangeCount -- > , const VkMappedMemoryRange* pMemoryRanges -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myFlushMappedMemoryRanges <- vkGetDeviceProc @VkFlushMappedMemoryRanges vkDevice -- -- or less efficient: -- -- > myFlushMappedMemoryRanges <- vkGetProc @VkFlushMappedMemoryRanges -- -- __Note:__ @vkFlushMappedMemoryRangesUnsafe@ and @vkFlushMappedMemoryRangesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkFlushMappedMemoryRanges@ is an alias -- of @vkFlushMappedMemoryRangesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkFlushMappedMemoryRangesSafe@. -- vkFlushMappedMemoryRanges :: VkDevice -- ^ device -> Word32 -- ^ memoryRangeCount -> Ptr VkMappedMemoryRange -- ^ pMemoryRanges -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkFlushMappedMemoryRanges = vkFlushMappedMemoryRangesUnsafe #else vkFlushMappedMemoryRanges = vkFlushMappedMemoryRangesSafe #endif {-# INLINE vkFlushMappedMemoryRanges #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkFlushMappedMemoryRanges -- > ( VkDevice device -- > , uint32_t memoryRangeCount -- > , const VkMappedMemoryRange* pMemoryRanges -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges registry at www.khronos.org> type HS_vkFlushMappedMemoryRanges = VkDevice -- ^ device -> Word32 -- ^ memoryRangeCount -> Ptr VkMappedMemoryRange -- ^ pMemoryRanges -> IO VkResult type PFN_vkFlushMappedMemoryRanges = FunPtr HS_vkFlushMappedMemoryRanges foreign import ccall unsafe "dynamic" unwrapVkFlushMappedMemoryRangesUnsafe :: PFN_vkFlushMappedMemoryRanges -> HS_vkFlushMappedMemoryRanges foreign import ccall safe "dynamic" unwrapVkFlushMappedMemoryRangesSafe :: PFN_vkFlushMappedMemoryRanges -> HS_vkFlushMappedMemoryRanges instance VulkanProc "vkFlushMappedMemoryRanges" where type VkProcType "vkFlushMappedMemoryRanges" = HS_vkFlushMappedMemoryRanges vkProcSymbol = _VkFlushMappedMemoryRanges {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkFlushMappedMemoryRangesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkFlushMappedMemoryRangesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkInvalidateMappedMemoryRanges :: CString pattern VkInvalidateMappedMemoryRanges <- (is_VkInvalidateMappedMemoryRanges -> True) where VkInvalidateMappedMemoryRanges = _VkInvalidateMappedMemoryRanges {-# INLINE _VkInvalidateMappedMemoryRanges #-} _VkInvalidateMappedMemoryRanges :: CString _VkInvalidateMappedMemoryRanges = Ptr "vkInvalidateMappedMemoryRanges\NUL"# {-# INLINE is_VkInvalidateMappedMemoryRanges #-} is_VkInvalidateMappedMemoryRanges :: CString -> Bool is_VkInvalidateMappedMemoryRanges = (EQ ==) . cmpCStrings _VkInvalidateMappedMemoryRanges type VkInvalidateMappedMemoryRanges = "vkInvalidateMappedMemoryRanges" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkInvalidateMappedMemoryRanges -- > ( VkDevice device -- > , uint32_t memoryRangeCount -- > , const VkMappedMemoryRange* pMemoryRanges -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myInvalidateMappedMemoryRanges <- vkGetDeviceProc @VkInvalidateMappedMemoryRanges vkDevice -- -- or less efficient: -- -- > myInvalidateMappedMemoryRanges <- vkGetProc @VkInvalidateMappedMemoryRanges -- -- __Note:__ @vkInvalidateMappedMemoryRangesUnsafe@ and @vkInvalidateMappedMemoryRangesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkInvalidateMappedMemoryRanges@ is an alias -- of @vkInvalidateMappedMemoryRangesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkInvalidateMappedMemoryRangesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkInvalidateMappedMemoryRanges" vkInvalidateMappedMemoryRangesUnsafe :: VkDevice -- ^ device -> Word32 -- ^ memoryRangeCount -> Ptr VkMappedMemoryRange -- ^ pMemoryRanges -> IO VkResult #else vkInvalidateMappedMemoryRangesUnsafe :: VkDevice -- ^ device -> Word32 -- ^ memoryRangeCount -> Ptr VkMappedMemoryRange -- ^ pMemoryRanges -> IO VkResult vkInvalidateMappedMemoryRangesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkInvalidateMappedMemoryRanges) {-# NOINLINE vkInvalidateMappedMemoryRangesUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkInvalidateMappedMemoryRanges -- > ( VkDevice device -- > , uint32_t memoryRangeCount -- > , const VkMappedMemoryRange* pMemoryRanges -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myInvalidateMappedMemoryRanges <- vkGetDeviceProc @VkInvalidateMappedMemoryRanges vkDevice -- -- or less efficient: -- -- > myInvalidateMappedMemoryRanges <- vkGetProc @VkInvalidateMappedMemoryRanges -- -- __Note:__ @vkInvalidateMappedMemoryRangesUnsafe@ and @vkInvalidateMappedMemoryRangesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkInvalidateMappedMemoryRanges@ is an alias -- of @vkInvalidateMappedMemoryRangesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkInvalidateMappedMemoryRangesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkInvalidateMappedMemoryRanges" vkInvalidateMappedMemoryRangesSafe :: VkDevice -- ^ device -> Word32 -- ^ memoryRangeCount -> Ptr VkMappedMemoryRange -- ^ pMemoryRanges -> IO VkResult #else vkInvalidateMappedMemoryRangesSafe :: VkDevice -- ^ device -> Word32 -- ^ memoryRangeCount -> Ptr VkMappedMemoryRange -- ^ pMemoryRanges -> IO VkResult vkInvalidateMappedMemoryRangesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkInvalidateMappedMemoryRanges) {-# NOINLINE vkInvalidateMappedMemoryRangesSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkInvalidateMappedMemoryRanges -- > ( VkDevice device -- > , uint32_t memoryRangeCount -- > , const VkMappedMemoryRange* pMemoryRanges -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myInvalidateMappedMemoryRanges <- vkGetDeviceProc @VkInvalidateMappedMemoryRanges vkDevice -- -- or less efficient: -- -- > myInvalidateMappedMemoryRanges <- vkGetProc @VkInvalidateMappedMemoryRanges -- -- __Note:__ @vkInvalidateMappedMemoryRangesUnsafe@ and @vkInvalidateMappedMemoryRangesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkInvalidateMappedMemoryRanges@ is an alias -- of @vkInvalidateMappedMemoryRangesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkInvalidateMappedMemoryRangesSafe@. -- vkInvalidateMappedMemoryRanges :: VkDevice -- ^ device -> Word32 -- ^ memoryRangeCount -> Ptr VkMappedMemoryRange -- ^ pMemoryRanges -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkInvalidateMappedMemoryRanges = vkInvalidateMappedMemoryRangesUnsafe #else vkInvalidateMappedMemoryRanges = vkInvalidateMappedMemoryRangesSafe #endif {-# INLINE vkInvalidateMappedMemoryRanges #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkInvalidateMappedMemoryRanges -- > ( VkDevice device -- > , uint32_t memoryRangeCount -- > , const VkMappedMemoryRange* pMemoryRanges -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges registry at www.khronos.org> type HS_vkInvalidateMappedMemoryRanges = VkDevice -- ^ device -> Word32 -- ^ memoryRangeCount -> Ptr VkMappedMemoryRange -- ^ pMemoryRanges -> IO VkResult type PFN_vkInvalidateMappedMemoryRanges = FunPtr HS_vkInvalidateMappedMemoryRanges foreign import ccall unsafe "dynamic" unwrapVkInvalidateMappedMemoryRangesUnsafe :: PFN_vkInvalidateMappedMemoryRanges -> HS_vkInvalidateMappedMemoryRanges foreign import ccall safe "dynamic" unwrapVkInvalidateMappedMemoryRangesSafe :: PFN_vkInvalidateMappedMemoryRanges -> HS_vkInvalidateMappedMemoryRanges instance VulkanProc "vkInvalidateMappedMemoryRanges" where type VkProcType "vkInvalidateMappedMemoryRanges" = HS_vkInvalidateMappedMemoryRanges vkProcSymbol = _VkInvalidateMappedMemoryRanges {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkInvalidateMappedMemoryRangesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkInvalidateMappedMemoryRangesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetDeviceMemoryCommitment :: CString pattern VkGetDeviceMemoryCommitment <- (is_VkGetDeviceMemoryCommitment -> True) where VkGetDeviceMemoryCommitment = _VkGetDeviceMemoryCommitment {-# INLINE _VkGetDeviceMemoryCommitment #-} _VkGetDeviceMemoryCommitment :: CString _VkGetDeviceMemoryCommitment = Ptr "vkGetDeviceMemoryCommitment\NUL"# {-# INLINE is_VkGetDeviceMemoryCommitment #-} is_VkGetDeviceMemoryCommitment :: CString -> Bool is_VkGetDeviceMemoryCommitment = (EQ ==) . cmpCStrings _VkGetDeviceMemoryCommitment type VkGetDeviceMemoryCommitment = "vkGetDeviceMemoryCommitment" -- | -- > void vkGetDeviceMemoryCommitment -- > ( VkDevice device -- > , VkDeviceMemory memory -- > , VkDeviceSize* pCommittedMemoryInBytes -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetDeviceMemoryCommitment <- vkGetDeviceProc @VkGetDeviceMemoryCommitment vkDevice -- -- or less efficient: -- -- > myGetDeviceMemoryCommitment <- vkGetProc @VkGetDeviceMemoryCommitment -- -- __Note:__ @vkGetDeviceMemoryCommitmentUnsafe@ and @vkGetDeviceMemoryCommitmentSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetDeviceMemoryCommitment@ is an alias -- of @vkGetDeviceMemoryCommitmentUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetDeviceMemoryCommitmentSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetDeviceMemoryCommitment" vkGetDeviceMemoryCommitmentUnsafe :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> Ptr VkDeviceSize -- ^ pCommittedMemoryInBytes -> IO () #else vkGetDeviceMemoryCommitmentUnsafe :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> Ptr VkDeviceSize -- ^ pCommittedMemoryInBytes -> IO () vkGetDeviceMemoryCommitmentUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetDeviceMemoryCommitment) {-# NOINLINE vkGetDeviceMemoryCommitmentUnsafe #-} #endif -- | -- > void vkGetDeviceMemoryCommitment -- > ( VkDevice device -- > , VkDeviceMemory memory -- > , VkDeviceSize* pCommittedMemoryInBytes -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetDeviceMemoryCommitment <- vkGetDeviceProc @VkGetDeviceMemoryCommitment vkDevice -- -- or less efficient: -- -- > myGetDeviceMemoryCommitment <- vkGetProc @VkGetDeviceMemoryCommitment -- -- __Note:__ @vkGetDeviceMemoryCommitmentUnsafe@ and @vkGetDeviceMemoryCommitmentSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetDeviceMemoryCommitment@ is an alias -- of @vkGetDeviceMemoryCommitmentUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetDeviceMemoryCommitmentSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetDeviceMemoryCommitment" vkGetDeviceMemoryCommitmentSafe :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> Ptr VkDeviceSize -- ^ pCommittedMemoryInBytes -> IO () #else vkGetDeviceMemoryCommitmentSafe :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> Ptr VkDeviceSize -- ^ pCommittedMemoryInBytes -> IO () vkGetDeviceMemoryCommitmentSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetDeviceMemoryCommitment) {-# NOINLINE vkGetDeviceMemoryCommitmentSafe #-} #endif -- | -- > void vkGetDeviceMemoryCommitment -- > ( VkDevice device -- > , VkDeviceMemory memory -- > , VkDeviceSize* pCommittedMemoryInBytes -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetDeviceMemoryCommitment <- vkGetDeviceProc @VkGetDeviceMemoryCommitment vkDevice -- -- or less efficient: -- -- > myGetDeviceMemoryCommitment <- vkGetProc @VkGetDeviceMemoryCommitment -- -- __Note:__ @vkGetDeviceMemoryCommitmentUnsafe@ and @vkGetDeviceMemoryCommitmentSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetDeviceMemoryCommitment@ is an alias -- of @vkGetDeviceMemoryCommitmentUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetDeviceMemoryCommitmentSafe@. -- vkGetDeviceMemoryCommitment :: VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> Ptr VkDeviceSize -- ^ pCommittedMemoryInBytes -> IO () #ifdef UNSAFE_FFI_DEFAULT vkGetDeviceMemoryCommitment = vkGetDeviceMemoryCommitmentUnsafe #else vkGetDeviceMemoryCommitment = vkGetDeviceMemoryCommitmentSafe #endif {-# INLINE vkGetDeviceMemoryCommitment #-} -- | > void vkGetDeviceMemoryCommitment -- > ( VkDevice device -- > , VkDeviceMemory memory -- > , VkDeviceSize* pCommittedMemoryInBytes -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment registry at www.khronos.org> type HS_vkGetDeviceMemoryCommitment = VkDevice -- ^ device -> VkDeviceMemory -- ^ memory -> Ptr VkDeviceSize -- ^ pCommittedMemoryInBytes -> IO () type PFN_vkGetDeviceMemoryCommitment = FunPtr HS_vkGetDeviceMemoryCommitment foreign import ccall unsafe "dynamic" unwrapVkGetDeviceMemoryCommitmentUnsafe :: PFN_vkGetDeviceMemoryCommitment -> HS_vkGetDeviceMemoryCommitment foreign import ccall safe "dynamic" unwrapVkGetDeviceMemoryCommitmentSafe :: PFN_vkGetDeviceMemoryCommitment -> HS_vkGetDeviceMemoryCommitment instance VulkanProc "vkGetDeviceMemoryCommitment" where type VkProcType "vkGetDeviceMemoryCommitment" = HS_vkGetDeviceMemoryCommitment vkProcSymbol = _VkGetDeviceMemoryCommitment {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetDeviceMemoryCommitmentUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetDeviceMemoryCommitmentSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkBindBufferMemory :: CString pattern VkBindBufferMemory <- (is_VkBindBufferMemory -> True) where VkBindBufferMemory = _VkBindBufferMemory {-# INLINE _VkBindBufferMemory #-} _VkBindBufferMemory :: CString _VkBindBufferMemory = Ptr "vkBindBufferMemory\NUL"# {-# INLINE is_VkBindBufferMemory #-} is_VkBindBufferMemory :: CString -> Bool is_VkBindBufferMemory = (EQ ==) . cmpCStrings _VkBindBufferMemory type VkBindBufferMemory = "vkBindBufferMemory" -- | -- 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 vkBindBufferMemory -- > ( VkDevice device -- > , VkBuffer buffer -- > , VkDeviceMemory memory -- > , VkDeviceSize memoryOffset -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBindBufferMemory vkBindBufferMemory registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myBindBufferMemory <- vkGetDeviceProc @VkBindBufferMemory vkDevice -- -- or less efficient: -- -- > myBindBufferMemory <- vkGetProc @VkBindBufferMemory -- -- __Note:__ @vkBindBufferMemoryUnsafe@ and @vkBindBufferMemorySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkBindBufferMemory@ is an alias -- of @vkBindBufferMemoryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkBindBufferMemorySafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkBindBufferMemory" vkBindBufferMemoryUnsafe :: VkDevice -- ^ device -> VkBuffer -- ^ buffer -> VkDeviceMemory -- ^ memory -> VkDeviceSize -- ^ memoryOffset -> IO VkResult #else vkBindBufferMemoryUnsafe :: VkDevice -- ^ device -> VkBuffer -- ^ buffer -> VkDeviceMemory -- ^ memory -> VkDeviceSize -- ^ memoryOffset -> IO VkResult vkBindBufferMemoryUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkBindBufferMemory) {-# NOINLINE vkBindBufferMemoryUnsafe #-} #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 vkBindBufferMemory -- > ( VkDevice device -- > , VkBuffer buffer -- > , VkDeviceMemory memory -- > , VkDeviceSize memoryOffset -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBindBufferMemory vkBindBufferMemory registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myBindBufferMemory <- vkGetDeviceProc @VkBindBufferMemory vkDevice -- -- or less efficient: -- -- > myBindBufferMemory <- vkGetProc @VkBindBufferMemory -- -- __Note:__ @vkBindBufferMemoryUnsafe@ and @vkBindBufferMemorySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkBindBufferMemory@ is an alias -- of @vkBindBufferMemoryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkBindBufferMemorySafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkBindBufferMemory" vkBindBufferMemorySafe :: VkDevice -- ^ device -> VkBuffer -- ^ buffer -> VkDeviceMemory -- ^ memory -> VkDeviceSize -- ^ memoryOffset -> IO VkResult #else vkBindBufferMemorySafe :: VkDevice -- ^ device -> VkBuffer -- ^ buffer -> VkDeviceMemory -- ^ memory -> VkDeviceSize -- ^ memoryOffset -> IO VkResult vkBindBufferMemorySafe = unsafeDupablePerformIO (vkGetProcSafe @VkBindBufferMemory) {-# NOINLINE vkBindBufferMemorySafe #-} #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 vkBindBufferMemory -- > ( VkDevice device -- > , VkBuffer buffer -- > , VkDeviceMemory memory -- > , VkDeviceSize memoryOffset -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBindBufferMemory vkBindBufferMemory registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myBindBufferMemory <- vkGetDeviceProc @VkBindBufferMemory vkDevice -- -- or less efficient: -- -- > myBindBufferMemory <- vkGetProc @VkBindBufferMemory -- -- __Note:__ @vkBindBufferMemoryUnsafe@ and @vkBindBufferMemorySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkBindBufferMemory@ is an alias -- of @vkBindBufferMemoryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkBindBufferMemorySafe@. -- vkBindBufferMemory :: VkDevice -- ^ device -> VkBuffer -- ^ buffer -> VkDeviceMemory -- ^ memory -> VkDeviceSize -- ^ memoryOffset -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkBindBufferMemory = vkBindBufferMemoryUnsafe #else vkBindBufferMemory = vkBindBufferMemorySafe #endif {-# INLINE vkBindBufferMemory #-} -- | 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 vkBindBufferMemory -- > ( VkDevice device -- > , VkBuffer buffer -- > , VkDeviceMemory memory -- > , VkDeviceSize memoryOffset -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBindBufferMemory vkBindBufferMemory registry at www.khronos.org> type HS_vkBindBufferMemory = VkDevice -- ^ device -> VkBuffer -- ^ buffer -> VkDeviceMemory -- ^ memory -> VkDeviceSize -- ^ memoryOffset -> IO VkResult type PFN_vkBindBufferMemory = FunPtr HS_vkBindBufferMemory foreign import ccall unsafe "dynamic" unwrapVkBindBufferMemoryUnsafe :: PFN_vkBindBufferMemory -> HS_vkBindBufferMemory foreign import ccall safe "dynamic" unwrapVkBindBufferMemorySafe :: PFN_vkBindBufferMemory -> HS_vkBindBufferMemory instance VulkanProc "vkBindBufferMemory" where type VkProcType "vkBindBufferMemory" = HS_vkBindBufferMemory vkProcSymbol = _VkBindBufferMemory {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkBindBufferMemoryUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkBindBufferMemorySafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkBindImageMemory :: CString pattern VkBindImageMemory <- (is_VkBindImageMemory -> True) where VkBindImageMemory = _VkBindImageMemory {-# INLINE _VkBindImageMemory #-} _VkBindImageMemory :: CString _VkBindImageMemory = Ptr "vkBindImageMemory\NUL"# {-# INLINE is_VkBindImageMemory #-} is_VkBindImageMemory :: CString -> Bool is_VkBindImageMemory = (EQ ==) . cmpCStrings _VkBindImageMemory type VkBindImageMemory = "vkBindImageMemory" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkBindImageMemory -- > ( VkDevice device -- > , VkImage image -- > , VkDeviceMemory memory -- > , VkDeviceSize memoryOffset -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBindImageMemory vkBindImageMemory registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myBindImageMemory <- vkGetDeviceProc @VkBindImageMemory vkDevice -- -- or less efficient: -- -- > myBindImageMemory <- vkGetProc @VkBindImageMemory -- -- __Note:__ @vkBindImageMemoryUnsafe@ and @vkBindImageMemorySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkBindImageMemory@ is an alias -- of @vkBindImageMemoryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkBindImageMemorySafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkBindImageMemory" vkBindImageMemoryUnsafe :: VkDevice -- ^ device -> VkImage -- ^ image -> VkDeviceMemory -- ^ memory -> VkDeviceSize -- ^ memoryOffset -> IO VkResult #else vkBindImageMemoryUnsafe :: VkDevice -- ^ device -> VkImage -- ^ image -> VkDeviceMemory -- ^ memory -> VkDeviceSize -- ^ memoryOffset -> IO VkResult vkBindImageMemoryUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkBindImageMemory) {-# NOINLINE vkBindImageMemoryUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkBindImageMemory -- > ( VkDevice device -- > , VkImage image -- > , VkDeviceMemory memory -- > , VkDeviceSize memoryOffset -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBindImageMemory vkBindImageMemory registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myBindImageMemory <- vkGetDeviceProc @VkBindImageMemory vkDevice -- -- or less efficient: -- -- > myBindImageMemory <- vkGetProc @VkBindImageMemory -- -- __Note:__ @vkBindImageMemoryUnsafe@ and @vkBindImageMemorySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkBindImageMemory@ is an alias -- of @vkBindImageMemoryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkBindImageMemorySafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkBindImageMemory" vkBindImageMemorySafe :: VkDevice -- ^ device -> VkImage -- ^ image -> VkDeviceMemory -- ^ memory -> VkDeviceSize -- ^ memoryOffset -> IO VkResult #else vkBindImageMemorySafe :: VkDevice -- ^ device -> VkImage -- ^ image -> VkDeviceMemory -- ^ memory -> VkDeviceSize -- ^ memoryOffset -> IO VkResult vkBindImageMemorySafe = unsafeDupablePerformIO (vkGetProcSafe @VkBindImageMemory) {-# NOINLINE vkBindImageMemorySafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkBindImageMemory -- > ( VkDevice device -- > , VkImage image -- > , VkDeviceMemory memory -- > , VkDeviceSize memoryOffset -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBindImageMemory vkBindImageMemory registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myBindImageMemory <- vkGetDeviceProc @VkBindImageMemory vkDevice -- -- or less efficient: -- -- > myBindImageMemory <- vkGetProc @VkBindImageMemory -- -- __Note:__ @vkBindImageMemoryUnsafe@ and @vkBindImageMemorySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkBindImageMemory@ is an alias -- of @vkBindImageMemoryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkBindImageMemorySafe@. -- vkBindImageMemory :: VkDevice -- ^ device -> VkImage -- ^ image -> VkDeviceMemory -- ^ memory -> VkDeviceSize -- ^ memoryOffset -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkBindImageMemory = vkBindImageMemoryUnsafe #else vkBindImageMemory = vkBindImageMemorySafe #endif {-# INLINE vkBindImageMemory #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkBindImageMemory -- > ( VkDevice device -- > , VkImage image -- > , VkDeviceMemory memory -- > , VkDeviceSize memoryOffset -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBindImageMemory vkBindImageMemory registry at www.khronos.org> type HS_vkBindImageMemory = VkDevice -- ^ device -> VkImage -- ^ image -> VkDeviceMemory -- ^ memory -> VkDeviceSize -- ^ memoryOffset -> IO VkResult type PFN_vkBindImageMemory = FunPtr HS_vkBindImageMemory foreign import ccall unsafe "dynamic" unwrapVkBindImageMemoryUnsafe :: PFN_vkBindImageMemory -> HS_vkBindImageMemory foreign import ccall safe "dynamic" unwrapVkBindImageMemorySafe :: PFN_vkBindImageMemory -> HS_vkBindImageMemory instance VulkanProc "vkBindImageMemory" where type VkProcType "vkBindImageMemory" = HS_vkBindImageMemory vkProcSymbol = _VkBindImageMemory {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkBindImageMemoryUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkBindImageMemorySafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetBufferMemoryRequirements :: CString pattern VkGetBufferMemoryRequirements <- (is_VkGetBufferMemoryRequirements -> True) where VkGetBufferMemoryRequirements = _VkGetBufferMemoryRequirements {-# INLINE _VkGetBufferMemoryRequirements #-} _VkGetBufferMemoryRequirements :: CString _VkGetBufferMemoryRequirements = Ptr "vkGetBufferMemoryRequirements\NUL"# {-# INLINE is_VkGetBufferMemoryRequirements #-} is_VkGetBufferMemoryRequirements :: CString -> Bool is_VkGetBufferMemoryRequirements = (EQ ==) . cmpCStrings _VkGetBufferMemoryRequirements type VkGetBufferMemoryRequirements = "vkGetBufferMemoryRequirements" -- | -- > void vkGetBufferMemoryRequirements -- > ( VkDevice device -- > , VkBuffer buffer -- > , VkMemoryRequirements* pMemoryRequirements -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetBufferMemoryRequirements <- vkGetDeviceProc @VkGetBufferMemoryRequirements vkDevice -- -- or less efficient: -- -- > myGetBufferMemoryRequirements <- vkGetProc @VkGetBufferMemoryRequirements -- -- __Note:__ @vkGetBufferMemoryRequirementsUnsafe@ and @vkGetBufferMemoryRequirementsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetBufferMemoryRequirements@ is an alias -- of @vkGetBufferMemoryRequirementsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetBufferMemoryRequirementsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetBufferMemoryRequirements" vkGetBufferMemoryRequirementsUnsafe :: VkDevice -- ^ device -> VkBuffer -- ^ buffer -> Ptr VkMemoryRequirements -- ^ pMemoryRequirements -> IO () #else vkGetBufferMemoryRequirementsUnsafe :: VkDevice -- ^ device -> VkBuffer -- ^ buffer -> Ptr VkMemoryRequirements -- ^ pMemoryRequirements -> IO () vkGetBufferMemoryRequirementsUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetBufferMemoryRequirements) {-# NOINLINE vkGetBufferMemoryRequirementsUnsafe #-} #endif -- | -- > void vkGetBufferMemoryRequirements -- > ( VkDevice device -- > , VkBuffer buffer -- > , VkMemoryRequirements* pMemoryRequirements -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetBufferMemoryRequirements <- vkGetDeviceProc @VkGetBufferMemoryRequirements vkDevice -- -- or less efficient: -- -- > myGetBufferMemoryRequirements <- vkGetProc @VkGetBufferMemoryRequirements -- -- __Note:__ @vkGetBufferMemoryRequirementsUnsafe@ and @vkGetBufferMemoryRequirementsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetBufferMemoryRequirements@ is an alias -- of @vkGetBufferMemoryRequirementsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetBufferMemoryRequirementsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetBufferMemoryRequirements" vkGetBufferMemoryRequirementsSafe :: VkDevice -- ^ device -> VkBuffer -- ^ buffer -> Ptr VkMemoryRequirements -- ^ pMemoryRequirements -> IO () #else vkGetBufferMemoryRequirementsSafe :: VkDevice -- ^ device -> VkBuffer -- ^ buffer -> Ptr VkMemoryRequirements -- ^ pMemoryRequirements -> IO () vkGetBufferMemoryRequirementsSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetBufferMemoryRequirements) {-# NOINLINE vkGetBufferMemoryRequirementsSafe #-} #endif -- | -- > void vkGetBufferMemoryRequirements -- > ( VkDevice device -- > , VkBuffer buffer -- > , VkMemoryRequirements* pMemoryRequirements -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetBufferMemoryRequirements <- vkGetDeviceProc @VkGetBufferMemoryRequirements vkDevice -- -- or less efficient: -- -- > myGetBufferMemoryRequirements <- vkGetProc @VkGetBufferMemoryRequirements -- -- __Note:__ @vkGetBufferMemoryRequirementsUnsafe@ and @vkGetBufferMemoryRequirementsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetBufferMemoryRequirements@ is an alias -- of @vkGetBufferMemoryRequirementsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetBufferMemoryRequirementsSafe@. -- vkGetBufferMemoryRequirements :: VkDevice -- ^ device -> VkBuffer -- ^ buffer -> Ptr VkMemoryRequirements -- ^ pMemoryRequirements -> IO () #ifdef UNSAFE_FFI_DEFAULT vkGetBufferMemoryRequirements = vkGetBufferMemoryRequirementsUnsafe #else vkGetBufferMemoryRequirements = vkGetBufferMemoryRequirementsSafe #endif {-# INLINE vkGetBufferMemoryRequirements #-} -- | > void vkGetBufferMemoryRequirements -- > ( VkDevice device -- > , VkBuffer buffer -- > , VkMemoryRequirements* pMemoryRequirements -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements registry at www.khronos.org> type HS_vkGetBufferMemoryRequirements = VkDevice -- ^ device -> VkBuffer -- ^ buffer -> Ptr VkMemoryRequirements -- ^ pMemoryRequirements -> IO () type PFN_vkGetBufferMemoryRequirements = FunPtr HS_vkGetBufferMemoryRequirements foreign import ccall unsafe "dynamic" unwrapVkGetBufferMemoryRequirementsUnsafe :: PFN_vkGetBufferMemoryRequirements -> HS_vkGetBufferMemoryRequirements foreign import ccall safe "dynamic" unwrapVkGetBufferMemoryRequirementsSafe :: PFN_vkGetBufferMemoryRequirements -> HS_vkGetBufferMemoryRequirements instance VulkanProc "vkGetBufferMemoryRequirements" where type VkProcType "vkGetBufferMemoryRequirements" = HS_vkGetBufferMemoryRequirements vkProcSymbol = _VkGetBufferMemoryRequirements {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetBufferMemoryRequirementsUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetBufferMemoryRequirementsSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetImageMemoryRequirements :: CString pattern VkGetImageMemoryRequirements <- (is_VkGetImageMemoryRequirements -> True) where VkGetImageMemoryRequirements = _VkGetImageMemoryRequirements {-# INLINE _VkGetImageMemoryRequirements #-} _VkGetImageMemoryRequirements :: CString _VkGetImageMemoryRequirements = Ptr "vkGetImageMemoryRequirements\NUL"# {-# INLINE is_VkGetImageMemoryRequirements #-} is_VkGetImageMemoryRequirements :: CString -> Bool is_VkGetImageMemoryRequirements = (EQ ==) . cmpCStrings _VkGetImageMemoryRequirements type VkGetImageMemoryRequirements = "vkGetImageMemoryRequirements" -- | -- > void vkGetImageMemoryRequirements -- > ( VkDevice device -- > , VkImage image -- > , VkMemoryRequirements* pMemoryRequirements -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageMemoryRequirements vkGetImageMemoryRequirements registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetImageMemoryRequirements <- vkGetDeviceProc @VkGetImageMemoryRequirements vkDevice -- -- or less efficient: -- -- > myGetImageMemoryRequirements <- vkGetProc @VkGetImageMemoryRequirements -- -- __Note:__ @vkGetImageMemoryRequirementsUnsafe@ and @vkGetImageMemoryRequirementsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetImageMemoryRequirements@ is an alias -- of @vkGetImageMemoryRequirementsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetImageMemoryRequirementsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetImageMemoryRequirements" vkGetImageMemoryRequirementsUnsafe :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr VkMemoryRequirements -- ^ pMemoryRequirements -> IO () #else vkGetImageMemoryRequirementsUnsafe :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr VkMemoryRequirements -- ^ pMemoryRequirements -> IO () vkGetImageMemoryRequirementsUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetImageMemoryRequirements) {-# NOINLINE vkGetImageMemoryRequirementsUnsafe #-} #endif -- | -- > void vkGetImageMemoryRequirements -- > ( VkDevice device -- > , VkImage image -- > , VkMemoryRequirements* pMemoryRequirements -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageMemoryRequirements vkGetImageMemoryRequirements registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetImageMemoryRequirements <- vkGetDeviceProc @VkGetImageMemoryRequirements vkDevice -- -- or less efficient: -- -- > myGetImageMemoryRequirements <- vkGetProc @VkGetImageMemoryRequirements -- -- __Note:__ @vkGetImageMemoryRequirementsUnsafe@ and @vkGetImageMemoryRequirementsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetImageMemoryRequirements@ is an alias -- of @vkGetImageMemoryRequirementsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetImageMemoryRequirementsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetImageMemoryRequirements" vkGetImageMemoryRequirementsSafe :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr VkMemoryRequirements -- ^ pMemoryRequirements -> IO () #else vkGetImageMemoryRequirementsSafe :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr VkMemoryRequirements -- ^ pMemoryRequirements -> IO () vkGetImageMemoryRequirementsSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetImageMemoryRequirements) {-# NOINLINE vkGetImageMemoryRequirementsSafe #-} #endif -- | -- > void vkGetImageMemoryRequirements -- > ( VkDevice device -- > , VkImage image -- > , VkMemoryRequirements* pMemoryRequirements -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageMemoryRequirements vkGetImageMemoryRequirements registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetImageMemoryRequirements <- vkGetDeviceProc @VkGetImageMemoryRequirements vkDevice -- -- or less efficient: -- -- > myGetImageMemoryRequirements <- vkGetProc @VkGetImageMemoryRequirements -- -- __Note:__ @vkGetImageMemoryRequirementsUnsafe@ and @vkGetImageMemoryRequirementsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetImageMemoryRequirements@ is an alias -- of @vkGetImageMemoryRequirementsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetImageMemoryRequirementsSafe@. -- vkGetImageMemoryRequirements :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr VkMemoryRequirements -- ^ pMemoryRequirements -> IO () #ifdef UNSAFE_FFI_DEFAULT vkGetImageMemoryRequirements = vkGetImageMemoryRequirementsUnsafe #else vkGetImageMemoryRequirements = vkGetImageMemoryRequirementsSafe #endif {-# INLINE vkGetImageMemoryRequirements #-} -- | > void vkGetImageMemoryRequirements -- > ( VkDevice device -- > , VkImage image -- > , VkMemoryRequirements* pMemoryRequirements -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageMemoryRequirements vkGetImageMemoryRequirements registry at www.khronos.org> type HS_vkGetImageMemoryRequirements = VkDevice -- ^ device -> VkImage -- ^ image -> Ptr VkMemoryRequirements -- ^ pMemoryRequirements -> IO () type PFN_vkGetImageMemoryRequirements = FunPtr HS_vkGetImageMemoryRequirements foreign import ccall unsafe "dynamic" unwrapVkGetImageMemoryRequirementsUnsafe :: PFN_vkGetImageMemoryRequirements -> HS_vkGetImageMemoryRequirements foreign import ccall safe "dynamic" unwrapVkGetImageMemoryRequirementsSafe :: PFN_vkGetImageMemoryRequirements -> HS_vkGetImageMemoryRequirements instance VulkanProc "vkGetImageMemoryRequirements" where type VkProcType "vkGetImageMemoryRequirements" = HS_vkGetImageMemoryRequirements vkProcSymbol = _VkGetImageMemoryRequirements {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetImageMemoryRequirementsUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetImageMemoryRequirementsSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetImageSparseMemoryRequirements :: CString pattern VkGetImageSparseMemoryRequirements <- (is_VkGetImageSparseMemoryRequirements -> True) where VkGetImageSparseMemoryRequirements = _VkGetImageSparseMemoryRequirements {-# INLINE _VkGetImageSparseMemoryRequirements #-} _VkGetImageSparseMemoryRequirements :: CString _VkGetImageSparseMemoryRequirements = Ptr "vkGetImageSparseMemoryRequirements\NUL"# {-# INLINE is_VkGetImageSparseMemoryRequirements #-} is_VkGetImageSparseMemoryRequirements :: CString -> Bool is_VkGetImageSparseMemoryRequirements = (EQ ==) . cmpCStrings _VkGetImageSparseMemoryRequirements type VkGetImageSparseMemoryRequirements = "vkGetImageSparseMemoryRequirements" -- | -- > void vkGetImageSparseMemoryRequirements -- > ( VkDevice device -- > , VkImage image -- > , uint32_t* pSparseMemoryRequirementCount -- > , VkSparseImageMemoryRequirements* pSparseMemoryRequirements -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetImageSparseMemoryRequirements <- vkGetDeviceProc @VkGetImageSparseMemoryRequirements vkDevice -- -- or less efficient: -- -- > myGetImageSparseMemoryRequirements <- vkGetProc @VkGetImageSparseMemoryRequirements -- -- __Note:__ @vkGetImageSparseMemoryRequirementsUnsafe@ and @vkGetImageSparseMemoryRequirementsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetImageSparseMemoryRequirements@ is an alias -- of @vkGetImageSparseMemoryRequirementsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetImageSparseMemoryRequirementsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetImageSparseMemoryRequirements" vkGetImageSparseMemoryRequirementsUnsafe :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr Word32 -- ^ pSparseMemoryRequirementCount -> Ptr VkSparseImageMemoryRequirements -- ^ pSparseMemoryRequirements -> IO () #else vkGetImageSparseMemoryRequirementsUnsafe :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr Word32 -- ^ pSparseMemoryRequirementCount -> Ptr VkSparseImageMemoryRequirements -- ^ pSparseMemoryRequirements -> IO () vkGetImageSparseMemoryRequirementsUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetImageSparseMemoryRequirements) {-# NOINLINE vkGetImageSparseMemoryRequirementsUnsafe #-} #endif -- | -- > void vkGetImageSparseMemoryRequirements -- > ( VkDevice device -- > , VkImage image -- > , uint32_t* pSparseMemoryRequirementCount -- > , VkSparseImageMemoryRequirements* pSparseMemoryRequirements -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetImageSparseMemoryRequirements <- vkGetDeviceProc @VkGetImageSparseMemoryRequirements vkDevice -- -- or less efficient: -- -- > myGetImageSparseMemoryRequirements <- vkGetProc @VkGetImageSparseMemoryRequirements -- -- __Note:__ @vkGetImageSparseMemoryRequirementsUnsafe@ and @vkGetImageSparseMemoryRequirementsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetImageSparseMemoryRequirements@ is an alias -- of @vkGetImageSparseMemoryRequirementsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetImageSparseMemoryRequirementsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetImageSparseMemoryRequirements" vkGetImageSparseMemoryRequirementsSafe :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr Word32 -- ^ pSparseMemoryRequirementCount -> Ptr VkSparseImageMemoryRequirements -- ^ pSparseMemoryRequirements -> IO () #else vkGetImageSparseMemoryRequirementsSafe :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr Word32 -- ^ pSparseMemoryRequirementCount -> Ptr VkSparseImageMemoryRequirements -- ^ pSparseMemoryRequirements -> IO () vkGetImageSparseMemoryRequirementsSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetImageSparseMemoryRequirements) {-# NOINLINE vkGetImageSparseMemoryRequirementsSafe #-} #endif -- | -- > void vkGetImageSparseMemoryRequirements -- > ( VkDevice device -- > , VkImage image -- > , uint32_t* pSparseMemoryRequirementCount -- > , VkSparseImageMemoryRequirements* pSparseMemoryRequirements -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetImageSparseMemoryRequirements <- vkGetDeviceProc @VkGetImageSparseMemoryRequirements vkDevice -- -- or less efficient: -- -- > myGetImageSparseMemoryRequirements <- vkGetProc @VkGetImageSparseMemoryRequirements -- -- __Note:__ @vkGetImageSparseMemoryRequirementsUnsafe@ and @vkGetImageSparseMemoryRequirementsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetImageSparseMemoryRequirements@ is an alias -- of @vkGetImageSparseMemoryRequirementsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetImageSparseMemoryRequirementsSafe@. -- vkGetImageSparseMemoryRequirements :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr Word32 -- ^ pSparseMemoryRequirementCount -> Ptr VkSparseImageMemoryRequirements -- ^ pSparseMemoryRequirements -> IO () #ifdef UNSAFE_FFI_DEFAULT vkGetImageSparseMemoryRequirements = vkGetImageSparseMemoryRequirementsUnsafe #else vkGetImageSparseMemoryRequirements = vkGetImageSparseMemoryRequirementsSafe #endif {-# INLINE vkGetImageSparseMemoryRequirements #-} -- | > void vkGetImageSparseMemoryRequirements -- > ( VkDevice device -- > , VkImage image -- > , uint32_t* pSparseMemoryRequirementCount -- > , VkSparseImageMemoryRequirements* pSparseMemoryRequirements -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements registry at www.khronos.org> type HS_vkGetImageSparseMemoryRequirements = VkDevice -- ^ device -> VkImage -- ^ image -> Ptr Word32 -- ^ pSparseMemoryRequirementCount -> Ptr VkSparseImageMemoryRequirements -- ^ pSparseMemoryRequirements -> IO () type PFN_vkGetImageSparseMemoryRequirements = FunPtr HS_vkGetImageSparseMemoryRequirements foreign import ccall unsafe "dynamic" unwrapVkGetImageSparseMemoryRequirementsUnsafe :: PFN_vkGetImageSparseMemoryRequirements -> HS_vkGetImageSparseMemoryRequirements foreign import ccall safe "dynamic" unwrapVkGetImageSparseMemoryRequirementsSafe :: PFN_vkGetImageSparseMemoryRequirements -> HS_vkGetImageSparseMemoryRequirements instance VulkanProc "vkGetImageSparseMemoryRequirements" where type VkProcType "vkGetImageSparseMemoryRequirements" = HS_vkGetImageSparseMemoryRequirements vkProcSymbol = _VkGetImageSparseMemoryRequirements {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetImageSparseMemoryRequirementsUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetImageSparseMemoryRequirementsSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetPhysicalDeviceSparseImageFormatProperties :: CString pattern VkGetPhysicalDeviceSparseImageFormatProperties <- (is_VkGetPhysicalDeviceSparseImageFormatProperties -> True) where VkGetPhysicalDeviceSparseImageFormatProperties = _VkGetPhysicalDeviceSparseImageFormatProperties {-# INLINE _VkGetPhysicalDeviceSparseImageFormatProperties #-} _VkGetPhysicalDeviceSparseImageFormatProperties :: CString _VkGetPhysicalDeviceSparseImageFormatProperties = Ptr "vkGetPhysicalDeviceSparseImageFormatProperties\NUL"# {-# INLINE is_VkGetPhysicalDeviceSparseImageFormatProperties #-} is_VkGetPhysicalDeviceSparseImageFormatProperties :: CString -> Bool is_VkGetPhysicalDeviceSparseImageFormatProperties = (EQ ==) . cmpCStrings _VkGetPhysicalDeviceSparseImageFormatProperties type VkGetPhysicalDeviceSparseImageFormatProperties = "vkGetPhysicalDeviceSparseImageFormatProperties" -- | -- > void vkGetPhysicalDeviceSparseImageFormatProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkFormat format -- > , VkImageType type -- > , VkSampleCountFlagBits samples -- > , VkImageUsageFlags usage -- > , VkImageTiling tiling -- > , uint32_t* pPropertyCount -- > , VkSparseImageFormatProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceSparseImageFormatProperties <- vkGetInstanceProc @VkGetPhysicalDeviceSparseImageFormatProperties vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceSparseImageFormatProperties <- vkGetProc @VkGetPhysicalDeviceSparseImageFormatProperties -- -- __Note:__ @vkGetPhysicalDeviceSparseImageFormatPropertiesUnsafe@ and @vkGetPhysicalDeviceSparseImageFormatPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceSparseImageFormatProperties@ is an alias -- of @vkGetPhysicalDeviceSparseImageFormatPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceSparseImageFormatPropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetPhysicalDeviceSparseImageFormatProperties" vkGetPhysicalDeviceSparseImageFormatPropertiesUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> VkFormat -- ^ format -> VkImageType -- ^ type -> VkSampleCountFlagBits -- ^ samples -> VkImageUsageFlags -- ^ usage -> VkImageTiling -- ^ tiling -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkSparseImageFormatProperties -- ^ pProperties -> IO () #else vkGetPhysicalDeviceSparseImageFormatPropertiesUnsafe :: VkPhysicalDevice -- ^ physicalDevice -> VkFormat -- ^ format -> VkImageType -- ^ type -> VkSampleCountFlagBits -- ^ samples -> VkImageUsageFlags -- ^ usage -> VkImageTiling -- ^ tiling -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkSparseImageFormatProperties -- ^ pProperties -> IO () vkGetPhysicalDeviceSparseImageFormatPropertiesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetPhysicalDeviceSparseImageFormatProperties) {-# NOINLINE vkGetPhysicalDeviceSparseImageFormatPropertiesUnsafe #-} #endif -- | -- > void vkGetPhysicalDeviceSparseImageFormatProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkFormat format -- > , VkImageType type -- > , VkSampleCountFlagBits samples -- > , VkImageUsageFlags usage -- > , VkImageTiling tiling -- > , uint32_t* pPropertyCount -- > , VkSparseImageFormatProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceSparseImageFormatProperties <- vkGetInstanceProc @VkGetPhysicalDeviceSparseImageFormatProperties vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceSparseImageFormatProperties <- vkGetProc @VkGetPhysicalDeviceSparseImageFormatProperties -- -- __Note:__ @vkGetPhysicalDeviceSparseImageFormatPropertiesUnsafe@ and @vkGetPhysicalDeviceSparseImageFormatPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceSparseImageFormatProperties@ is an alias -- of @vkGetPhysicalDeviceSparseImageFormatPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceSparseImageFormatPropertiesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetPhysicalDeviceSparseImageFormatProperties" vkGetPhysicalDeviceSparseImageFormatPropertiesSafe :: VkPhysicalDevice -- ^ physicalDevice -> VkFormat -- ^ format -> VkImageType -- ^ type -> VkSampleCountFlagBits -- ^ samples -> VkImageUsageFlags -- ^ usage -> VkImageTiling -- ^ tiling -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkSparseImageFormatProperties -- ^ pProperties -> IO () #else vkGetPhysicalDeviceSparseImageFormatPropertiesSafe :: VkPhysicalDevice -- ^ physicalDevice -> VkFormat -- ^ format -> VkImageType -- ^ type -> VkSampleCountFlagBits -- ^ samples -> VkImageUsageFlags -- ^ usage -> VkImageTiling -- ^ tiling -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkSparseImageFormatProperties -- ^ pProperties -> IO () vkGetPhysicalDeviceSparseImageFormatPropertiesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetPhysicalDeviceSparseImageFormatProperties) {-# NOINLINE vkGetPhysicalDeviceSparseImageFormatPropertiesSafe #-} #endif -- | -- > void vkGetPhysicalDeviceSparseImageFormatProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkFormat format -- > , VkImageType type -- > , VkSampleCountFlagBits samples -- > , VkImageUsageFlags usage -- > , VkImageTiling tiling -- > , uint32_t* pPropertyCount -- > , VkSparseImageFormatProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPhysicalDeviceSparseImageFormatProperties <- vkGetInstanceProc @VkGetPhysicalDeviceSparseImageFormatProperties vkInstance -- -- or less efficient: -- -- > myGetPhysicalDeviceSparseImageFormatProperties <- vkGetProc @VkGetPhysicalDeviceSparseImageFormatProperties -- -- __Note:__ @vkGetPhysicalDeviceSparseImageFormatPropertiesUnsafe@ and @vkGetPhysicalDeviceSparseImageFormatPropertiesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPhysicalDeviceSparseImageFormatProperties@ is an alias -- of @vkGetPhysicalDeviceSparseImageFormatPropertiesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPhysicalDeviceSparseImageFormatPropertiesSafe@. -- vkGetPhysicalDeviceSparseImageFormatProperties :: VkPhysicalDevice -- ^ physicalDevice -> VkFormat -- ^ format -> VkImageType -- ^ type -> VkSampleCountFlagBits -- ^ samples -> VkImageUsageFlags -- ^ usage -> VkImageTiling -- ^ tiling -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkSparseImageFormatProperties -- ^ pProperties -> IO () #ifdef UNSAFE_FFI_DEFAULT vkGetPhysicalDeviceSparseImageFormatProperties = vkGetPhysicalDeviceSparseImageFormatPropertiesUnsafe #else vkGetPhysicalDeviceSparseImageFormatProperties = vkGetPhysicalDeviceSparseImageFormatPropertiesSafe #endif {-# INLINE vkGetPhysicalDeviceSparseImageFormatProperties #-} -- | > void vkGetPhysicalDeviceSparseImageFormatProperties -- > ( VkPhysicalDevice physicalDevice -- > , VkFormat format -- > , VkImageType type -- > , VkSampleCountFlagBits samples -- > , VkImageUsageFlags usage -- > , VkImageTiling tiling -- > , uint32_t* pPropertyCount -- > , VkSparseImageFormatProperties* pProperties -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties registry at www.khronos.org> type HS_vkGetPhysicalDeviceSparseImageFormatProperties = VkPhysicalDevice -- ^ physicalDevice -> VkFormat -- ^ format -> VkImageType -- ^ type -> VkSampleCountFlagBits -- ^ samples -> VkImageUsageFlags -- ^ usage -> VkImageTiling -- ^ tiling -> Ptr Word32 -- ^ pPropertyCount -> Ptr VkSparseImageFormatProperties -- ^ pProperties -> IO () type PFN_vkGetPhysicalDeviceSparseImageFormatProperties = FunPtr HS_vkGetPhysicalDeviceSparseImageFormatProperties foreign import ccall unsafe "dynamic" unwrapVkGetPhysicalDeviceSparseImageFormatPropertiesUnsafe :: PFN_vkGetPhysicalDeviceSparseImageFormatProperties -> HS_vkGetPhysicalDeviceSparseImageFormatProperties foreign import ccall safe "dynamic" unwrapVkGetPhysicalDeviceSparseImageFormatPropertiesSafe :: PFN_vkGetPhysicalDeviceSparseImageFormatProperties -> HS_vkGetPhysicalDeviceSparseImageFormatProperties instance VulkanProc "vkGetPhysicalDeviceSparseImageFormatProperties" where type VkProcType "vkGetPhysicalDeviceSparseImageFormatProperties" = HS_vkGetPhysicalDeviceSparseImageFormatProperties vkProcSymbol = _VkGetPhysicalDeviceSparseImageFormatProperties {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetPhysicalDeviceSparseImageFormatPropertiesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetPhysicalDeviceSparseImageFormatPropertiesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkQueueBindSparse :: CString pattern VkQueueBindSparse <- (is_VkQueueBindSparse -> True) where VkQueueBindSparse = _VkQueueBindSparse {-# INLINE _VkQueueBindSparse #-} _VkQueueBindSparse :: CString _VkQueueBindSparse = Ptr "vkQueueBindSparse\NUL"# {-# INLINE is_VkQueueBindSparse #-} is_VkQueueBindSparse :: CString -> Bool is_VkQueueBindSparse = (EQ ==) . cmpCStrings _VkQueueBindSparse type VkQueueBindSparse = "vkQueueBindSparse" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- Queues: 'sparse_binding'. -- -- > VkResult vkQueueBindSparse -- > ( VkQueue queue -- > , uint32_t bindInfoCount -- > , const VkBindSparseInfo* pBindInfo -- > , VkFence fence -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkQueueBindSparse vkQueueBindSparse registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myQueueBindSparse <- vkGetInstanceProc @VkQueueBindSparse vkInstance -- -- or less efficient: -- -- > myQueueBindSparse <- vkGetProc @VkQueueBindSparse -- -- __Note:__ @vkQueueBindSparseUnsafe@ and @vkQueueBindSparseSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkQueueBindSparse@ is an alias -- of @vkQueueBindSparseUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkQueueBindSparseSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkQueueBindSparse" vkQueueBindSparseUnsafe :: VkQueue -- ^ queue -> Word32 -- ^ bindInfoCount -> Ptr VkBindSparseInfo -- ^ pBindInfo -> VkFence -- ^ fence -> IO VkResult #else vkQueueBindSparseUnsafe :: VkQueue -- ^ queue -> Word32 -- ^ bindInfoCount -> Ptr VkBindSparseInfo -- ^ pBindInfo -> VkFence -- ^ fence -> IO VkResult vkQueueBindSparseUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkQueueBindSparse) {-# NOINLINE vkQueueBindSparseUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- Queues: 'sparse_binding'. -- -- > VkResult vkQueueBindSparse -- > ( VkQueue queue -- > , uint32_t bindInfoCount -- > , const VkBindSparseInfo* pBindInfo -- > , VkFence fence -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkQueueBindSparse vkQueueBindSparse registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myQueueBindSparse <- vkGetInstanceProc @VkQueueBindSparse vkInstance -- -- or less efficient: -- -- > myQueueBindSparse <- vkGetProc @VkQueueBindSparse -- -- __Note:__ @vkQueueBindSparseUnsafe@ and @vkQueueBindSparseSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkQueueBindSparse@ is an alias -- of @vkQueueBindSparseUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkQueueBindSparseSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkQueueBindSparse" vkQueueBindSparseSafe :: VkQueue -- ^ queue -> Word32 -- ^ bindInfoCount -> Ptr VkBindSparseInfo -- ^ pBindInfo -> VkFence -- ^ fence -> IO VkResult #else vkQueueBindSparseSafe :: VkQueue -- ^ queue -> Word32 -- ^ bindInfoCount -> Ptr VkBindSparseInfo -- ^ pBindInfo -> VkFence -- ^ fence -> IO VkResult vkQueueBindSparseSafe = unsafeDupablePerformIO (vkGetProcSafe @VkQueueBindSparse) {-# NOINLINE vkQueueBindSparseSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- Queues: 'sparse_binding'. -- -- > VkResult vkQueueBindSparse -- > ( VkQueue queue -- > , uint32_t bindInfoCount -- > , const VkBindSparseInfo* pBindInfo -- > , VkFence fence -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkQueueBindSparse vkQueueBindSparse registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myQueueBindSparse <- vkGetInstanceProc @VkQueueBindSparse vkInstance -- -- or less efficient: -- -- > myQueueBindSparse <- vkGetProc @VkQueueBindSparse -- -- __Note:__ @vkQueueBindSparseUnsafe@ and @vkQueueBindSparseSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkQueueBindSparse@ is an alias -- of @vkQueueBindSparseUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkQueueBindSparseSafe@. -- vkQueueBindSparse :: VkQueue -- ^ queue -> Word32 -- ^ bindInfoCount -> Ptr VkBindSparseInfo -- ^ pBindInfo -> VkFence -- ^ fence -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkQueueBindSparse = vkQueueBindSparseUnsafe #else vkQueueBindSparse = vkQueueBindSparseSafe #endif {-# INLINE vkQueueBindSparse #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- Queues: 'sparse_binding'. -- -- > VkResult vkQueueBindSparse -- > ( VkQueue queue -- > , uint32_t bindInfoCount -- > , const VkBindSparseInfo* pBindInfo -- > , VkFence fence -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkQueueBindSparse vkQueueBindSparse registry at www.khronos.org> type HS_vkQueueBindSparse = VkQueue -- ^ queue -> Word32 -- ^ bindInfoCount -> Ptr VkBindSparseInfo -- ^ pBindInfo -> VkFence -- ^ fence -> IO VkResult type PFN_vkQueueBindSparse = FunPtr HS_vkQueueBindSparse foreign import ccall unsafe "dynamic" unwrapVkQueueBindSparseUnsafe :: PFN_vkQueueBindSparse -> HS_vkQueueBindSparse foreign import ccall safe "dynamic" unwrapVkQueueBindSparseSafe :: PFN_vkQueueBindSparse -> HS_vkQueueBindSparse instance VulkanProc "vkQueueBindSparse" where type VkProcType "vkQueueBindSparse" = HS_vkQueueBindSparse vkProcSymbol = _VkQueueBindSparse {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkQueueBindSparseUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkQueueBindSparseSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreateFence :: CString pattern VkCreateFence <- (is_VkCreateFence -> True) where VkCreateFence = _VkCreateFence {-# INLINE _VkCreateFence #-} _VkCreateFence :: CString _VkCreateFence = Ptr "vkCreateFence\NUL"# {-# INLINE is_VkCreateFence #-} is_VkCreateFence :: CString -> Bool is_VkCreateFence = (EQ ==) . cmpCStrings _VkCreateFence type VkCreateFence = "vkCreateFence" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateFence -- > ( VkDevice device -- > , const VkFenceCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkFence* pFence -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateFence vkCreateFence registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateFence <- vkGetDeviceProc @VkCreateFence vkDevice -- -- or less efficient: -- -- > myCreateFence <- vkGetProc @VkCreateFence -- -- __Note:__ @vkCreateFenceUnsafe@ and @vkCreateFenceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateFence@ is an alias -- of @vkCreateFenceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateFenceSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateFence" vkCreateFenceUnsafe :: VkDevice -- ^ device -> Ptr VkFenceCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkFence -- ^ pFence -> IO VkResult #else vkCreateFenceUnsafe :: VkDevice -- ^ device -> Ptr VkFenceCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkFence -- ^ pFence -> IO VkResult vkCreateFenceUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateFence) {-# NOINLINE vkCreateFenceUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateFence -- > ( VkDevice device -- > , const VkFenceCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkFence* pFence -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateFence vkCreateFence registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateFence <- vkGetDeviceProc @VkCreateFence vkDevice -- -- or less efficient: -- -- > myCreateFence <- vkGetProc @VkCreateFence -- -- __Note:__ @vkCreateFenceUnsafe@ and @vkCreateFenceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateFence@ is an alias -- of @vkCreateFenceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateFenceSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateFence" vkCreateFenceSafe :: VkDevice -- ^ device -> Ptr VkFenceCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkFence -- ^ pFence -> IO VkResult #else vkCreateFenceSafe :: VkDevice -- ^ device -> Ptr VkFenceCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkFence -- ^ pFence -> IO VkResult vkCreateFenceSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateFence) {-# NOINLINE vkCreateFenceSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateFence -- > ( VkDevice device -- > , const VkFenceCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkFence* pFence -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateFence vkCreateFence registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateFence <- vkGetDeviceProc @VkCreateFence vkDevice -- -- or less efficient: -- -- > myCreateFence <- vkGetProc @VkCreateFence -- -- __Note:__ @vkCreateFenceUnsafe@ and @vkCreateFenceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateFence@ is an alias -- of @vkCreateFenceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateFenceSafe@. -- vkCreateFence :: VkDevice -- ^ device -> Ptr VkFenceCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkFence -- ^ pFence -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateFence = vkCreateFenceUnsafe #else vkCreateFence = vkCreateFenceSafe #endif {-# INLINE vkCreateFence #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateFence -- > ( VkDevice device -- > , const VkFenceCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkFence* pFence -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateFence vkCreateFence registry at www.khronos.org> type HS_vkCreateFence = VkDevice -- ^ device -> Ptr VkFenceCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkFence -- ^ pFence -> IO VkResult type PFN_vkCreateFence = FunPtr HS_vkCreateFence foreign import ccall unsafe "dynamic" unwrapVkCreateFenceUnsafe :: PFN_vkCreateFence -> HS_vkCreateFence foreign import ccall safe "dynamic" unwrapVkCreateFenceSafe :: PFN_vkCreateFence -> HS_vkCreateFence instance VulkanProc "vkCreateFence" where type VkProcType "vkCreateFence" = HS_vkCreateFence vkProcSymbol = _VkCreateFence {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateFenceUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateFenceSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroyFence :: CString pattern VkDestroyFence <- (is_VkDestroyFence -> True) where VkDestroyFence = _VkDestroyFence {-# INLINE _VkDestroyFence #-} _VkDestroyFence :: CString _VkDestroyFence = Ptr "vkDestroyFence\NUL"# {-# INLINE is_VkDestroyFence #-} is_VkDestroyFence :: CString -> Bool is_VkDestroyFence = (EQ ==) . cmpCStrings _VkDestroyFence type VkDestroyFence = "vkDestroyFence" -- | -- > void vkDestroyFence -- > ( VkDevice device -- > , VkFence fence -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyFence vkDestroyFence registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyFence <- vkGetDeviceProc @VkDestroyFence vkDevice -- -- or less efficient: -- -- > myDestroyFence <- vkGetProc @VkDestroyFence -- -- __Note:__ @vkDestroyFenceUnsafe@ and @vkDestroyFenceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyFence@ is an alias -- of @vkDestroyFenceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyFenceSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroyFence" vkDestroyFenceUnsafe :: VkDevice -- ^ device -> VkFence -- ^ fence -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyFenceUnsafe :: VkDevice -- ^ device -> VkFence -- ^ fence -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyFenceUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroyFence) {-# NOINLINE vkDestroyFenceUnsafe #-} #endif -- | -- > void vkDestroyFence -- > ( VkDevice device -- > , VkFence fence -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyFence vkDestroyFence registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyFence <- vkGetDeviceProc @VkDestroyFence vkDevice -- -- or less efficient: -- -- > myDestroyFence <- vkGetProc @VkDestroyFence -- -- __Note:__ @vkDestroyFenceUnsafe@ and @vkDestroyFenceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyFence@ is an alias -- of @vkDestroyFenceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyFenceSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroyFence" vkDestroyFenceSafe :: VkDevice -- ^ device -> VkFence -- ^ fence -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyFenceSafe :: VkDevice -- ^ device -> VkFence -- ^ fence -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyFenceSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroyFence) {-# NOINLINE vkDestroyFenceSafe #-} #endif -- | -- > void vkDestroyFence -- > ( VkDevice device -- > , VkFence fence -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyFence vkDestroyFence registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyFence <- vkGetDeviceProc @VkDestroyFence vkDevice -- -- or less efficient: -- -- > myDestroyFence <- vkGetProc @VkDestroyFence -- -- __Note:__ @vkDestroyFenceUnsafe@ and @vkDestroyFenceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyFence@ is an alias -- of @vkDestroyFenceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyFenceSafe@. -- vkDestroyFence :: VkDevice -- ^ device -> VkFence -- ^ fence -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroyFence = vkDestroyFenceUnsafe #else vkDestroyFence = vkDestroyFenceSafe #endif {-# INLINE vkDestroyFence #-} -- | > void vkDestroyFence -- > ( VkDevice device -- > , VkFence fence -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyFence vkDestroyFence registry at www.khronos.org> type HS_vkDestroyFence = VkDevice -- ^ device -> VkFence -- ^ fence -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroyFence = FunPtr HS_vkDestroyFence foreign import ccall unsafe "dynamic" unwrapVkDestroyFenceUnsafe :: PFN_vkDestroyFence -> HS_vkDestroyFence foreign import ccall safe "dynamic" unwrapVkDestroyFenceSafe :: PFN_vkDestroyFence -> HS_vkDestroyFence instance VulkanProc "vkDestroyFence" where type VkProcType "vkDestroyFence" = HS_vkDestroyFence vkProcSymbol = _VkDestroyFence {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroyFenceUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroyFenceSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkResetFences :: CString pattern VkResetFences <- (is_VkResetFences -> True) where VkResetFences = _VkResetFences {-# INLINE _VkResetFences #-} _VkResetFences :: CString _VkResetFences = Ptr "vkResetFences\NUL"# {-# INLINE is_VkResetFences #-} is_VkResetFences :: CString -> Bool is_VkResetFences = (EQ ==) . cmpCStrings _VkResetFences type VkResetFences = "vkResetFences" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkResetFences -- > ( VkDevice device -- > , uint32_t fenceCount -- > , const VkFence* pFences -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetFences vkResetFences registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myResetFences <- vkGetDeviceProc @VkResetFences vkDevice -- -- or less efficient: -- -- > myResetFences <- vkGetProc @VkResetFences -- -- __Note:__ @vkResetFencesUnsafe@ and @vkResetFencesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkResetFences@ is an alias -- of @vkResetFencesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkResetFencesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkResetFences" vkResetFencesUnsafe :: VkDevice -- ^ device -> Word32 -- ^ fenceCount -> Ptr VkFence -- ^ pFences -> IO VkResult #else vkResetFencesUnsafe :: VkDevice -- ^ device -> Word32 -- ^ fenceCount -> Ptr VkFence -- ^ pFences -> IO VkResult vkResetFencesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkResetFences) {-# NOINLINE vkResetFencesUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkResetFences -- > ( VkDevice device -- > , uint32_t fenceCount -- > , const VkFence* pFences -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetFences vkResetFences registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myResetFences <- vkGetDeviceProc @VkResetFences vkDevice -- -- or less efficient: -- -- > myResetFences <- vkGetProc @VkResetFences -- -- __Note:__ @vkResetFencesUnsafe@ and @vkResetFencesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkResetFences@ is an alias -- of @vkResetFencesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkResetFencesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkResetFences" vkResetFencesSafe :: VkDevice -- ^ device -> Word32 -- ^ fenceCount -> Ptr VkFence -- ^ pFences -> IO VkResult #else vkResetFencesSafe :: VkDevice -- ^ device -> Word32 -- ^ fenceCount -> Ptr VkFence -- ^ pFences -> IO VkResult vkResetFencesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkResetFences) {-# NOINLINE vkResetFencesSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkResetFences -- > ( VkDevice device -- > , uint32_t fenceCount -- > , const VkFence* pFences -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetFences vkResetFences registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myResetFences <- vkGetDeviceProc @VkResetFences vkDevice -- -- or less efficient: -- -- > myResetFences <- vkGetProc @VkResetFences -- -- __Note:__ @vkResetFencesUnsafe@ and @vkResetFencesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkResetFences@ is an alias -- of @vkResetFencesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkResetFencesSafe@. -- vkResetFences :: VkDevice -- ^ device -> Word32 -- ^ fenceCount -> Ptr VkFence -- ^ pFences -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkResetFences = vkResetFencesUnsafe #else vkResetFences = vkResetFencesSafe #endif {-# INLINE vkResetFences #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkResetFences -- > ( VkDevice device -- > , uint32_t fenceCount -- > , const VkFence* pFences -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetFences vkResetFences registry at www.khronos.org> type HS_vkResetFences = VkDevice -- ^ device -> Word32 -- ^ fenceCount -> Ptr VkFence -- ^ pFences -> IO VkResult type PFN_vkResetFences = FunPtr HS_vkResetFences foreign import ccall unsafe "dynamic" unwrapVkResetFencesUnsafe :: PFN_vkResetFences -> HS_vkResetFences foreign import ccall safe "dynamic" unwrapVkResetFencesSafe :: PFN_vkResetFences -> HS_vkResetFences instance VulkanProc "vkResetFences" where type VkProcType "vkResetFences" = HS_vkResetFences vkProcSymbol = _VkResetFences {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkResetFencesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkResetFencesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetFenceStatus :: CString pattern VkGetFenceStatus <- (is_VkGetFenceStatus -> True) where VkGetFenceStatus = _VkGetFenceStatus {-# INLINE _VkGetFenceStatus #-} _VkGetFenceStatus :: CString _VkGetFenceStatus = Ptr "vkGetFenceStatus\NUL"# {-# INLINE is_VkGetFenceStatus #-} is_VkGetFenceStatus :: CString -> Bool is_VkGetFenceStatus = (EQ ==) . cmpCStrings _VkGetFenceStatus type VkGetFenceStatus = "vkGetFenceStatus" -- | -- Success codes: 'VK_SUCCESS', 'VK_NOT_READY'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkGetFenceStatus -- > ( VkDevice device -- > , VkFence fence -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetFenceStatus vkGetFenceStatus registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetFenceStatus <- vkGetDeviceProc @VkGetFenceStatus vkDevice -- -- or less efficient: -- -- > myGetFenceStatus <- vkGetProc @VkGetFenceStatus -- -- __Note:__ @vkGetFenceStatusUnsafe@ and @vkGetFenceStatusSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetFenceStatus@ is an alias -- of @vkGetFenceStatusUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetFenceStatusSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetFenceStatus" vkGetFenceStatusUnsafe :: VkDevice -- ^ device -> VkFence -- ^ fence -> IO VkResult #else vkGetFenceStatusUnsafe :: VkDevice -- ^ device -> VkFence -- ^ fence -> IO VkResult vkGetFenceStatusUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetFenceStatus) {-# NOINLINE vkGetFenceStatusUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_NOT_READY'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkGetFenceStatus -- > ( VkDevice device -- > , VkFence fence -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetFenceStatus vkGetFenceStatus registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetFenceStatus <- vkGetDeviceProc @VkGetFenceStatus vkDevice -- -- or less efficient: -- -- > myGetFenceStatus <- vkGetProc @VkGetFenceStatus -- -- __Note:__ @vkGetFenceStatusUnsafe@ and @vkGetFenceStatusSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetFenceStatus@ is an alias -- of @vkGetFenceStatusUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetFenceStatusSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetFenceStatus" vkGetFenceStatusSafe :: VkDevice -- ^ device -> VkFence -- ^ fence -> IO VkResult #else vkGetFenceStatusSafe :: VkDevice -- ^ device -> VkFence -- ^ fence -> IO VkResult vkGetFenceStatusSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetFenceStatus) {-# NOINLINE vkGetFenceStatusSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_NOT_READY'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkGetFenceStatus -- > ( VkDevice device -- > , VkFence fence -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetFenceStatus vkGetFenceStatus registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetFenceStatus <- vkGetDeviceProc @VkGetFenceStatus vkDevice -- -- or less efficient: -- -- > myGetFenceStatus <- vkGetProc @VkGetFenceStatus -- -- __Note:__ @vkGetFenceStatusUnsafe@ and @vkGetFenceStatusSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetFenceStatus@ is an alias -- of @vkGetFenceStatusUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetFenceStatusSafe@. -- vkGetFenceStatus :: VkDevice -- ^ device -> VkFence -- ^ fence -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkGetFenceStatus = vkGetFenceStatusUnsafe #else vkGetFenceStatus = vkGetFenceStatusSafe #endif {-# INLINE vkGetFenceStatus #-} -- | Success codes: 'VK_SUCCESS', 'VK_NOT_READY'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkGetFenceStatus -- > ( VkDevice device -- > , VkFence fence -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetFenceStatus vkGetFenceStatus registry at www.khronos.org> type HS_vkGetFenceStatus = VkDevice -- ^ device -> VkFence -- ^ fence -> IO VkResult type PFN_vkGetFenceStatus = FunPtr HS_vkGetFenceStatus foreign import ccall unsafe "dynamic" unwrapVkGetFenceStatusUnsafe :: PFN_vkGetFenceStatus -> HS_vkGetFenceStatus foreign import ccall safe "dynamic" unwrapVkGetFenceStatusSafe :: PFN_vkGetFenceStatus -> HS_vkGetFenceStatus instance VulkanProc "vkGetFenceStatus" where type VkProcType "vkGetFenceStatus" = HS_vkGetFenceStatus vkProcSymbol = _VkGetFenceStatus {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetFenceStatusUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetFenceStatusSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkWaitForFences :: CString pattern VkWaitForFences <- (is_VkWaitForFences -> True) where VkWaitForFences = _VkWaitForFences {-# INLINE _VkWaitForFences #-} _VkWaitForFences :: CString _VkWaitForFences = Ptr "vkWaitForFences\NUL"# {-# INLINE is_VkWaitForFences #-} is_VkWaitForFences :: CString -> Bool is_VkWaitForFences = (EQ ==) . cmpCStrings _VkWaitForFences type VkWaitForFences = "vkWaitForFences" -- | -- Success codes: 'VK_SUCCESS', 'VK_TIMEOUT'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkWaitForFences -- > ( VkDevice device -- > , uint32_t fenceCount -- > , const VkFence* pFences -- > , VkBool32 waitAll -- > , uint64_t timeout -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkWaitForFences vkWaitForFences registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myWaitForFences <- vkGetDeviceProc @VkWaitForFences vkDevice -- -- or less efficient: -- -- > myWaitForFences <- vkGetProc @VkWaitForFences -- -- __Note:__ @vkWaitForFencesUnsafe@ and @vkWaitForFencesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkWaitForFences@ is an alias -- of @vkWaitForFencesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkWaitForFencesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkWaitForFences" vkWaitForFencesUnsafe :: VkDevice -- ^ device -> Word32 -- ^ fenceCount -> Ptr VkFence -- ^ pFences -> VkBool32 -- ^ waitAll -> Word64 -- ^ timeout -> IO VkResult #else vkWaitForFencesUnsafe :: VkDevice -- ^ device -> Word32 -- ^ fenceCount -> Ptr VkFence -- ^ pFences -> VkBool32 -- ^ waitAll -> Word64 -- ^ timeout -> IO VkResult vkWaitForFencesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkWaitForFences) {-# NOINLINE vkWaitForFencesUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_TIMEOUT'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkWaitForFences -- > ( VkDevice device -- > , uint32_t fenceCount -- > , const VkFence* pFences -- > , VkBool32 waitAll -- > , uint64_t timeout -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkWaitForFences vkWaitForFences registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myWaitForFences <- vkGetDeviceProc @VkWaitForFences vkDevice -- -- or less efficient: -- -- > myWaitForFences <- vkGetProc @VkWaitForFences -- -- __Note:__ @vkWaitForFencesUnsafe@ and @vkWaitForFencesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkWaitForFences@ is an alias -- of @vkWaitForFencesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkWaitForFencesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkWaitForFences" vkWaitForFencesSafe :: VkDevice -- ^ device -> Word32 -- ^ fenceCount -> Ptr VkFence -- ^ pFences -> VkBool32 -- ^ waitAll -> Word64 -- ^ timeout -> IO VkResult #else vkWaitForFencesSafe :: VkDevice -- ^ device -> Word32 -- ^ fenceCount -> Ptr VkFence -- ^ pFences -> VkBool32 -- ^ waitAll -> Word64 -- ^ timeout -> IO VkResult vkWaitForFencesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkWaitForFences) {-# NOINLINE vkWaitForFencesSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_TIMEOUT'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkWaitForFences -- > ( VkDevice device -- > , uint32_t fenceCount -- > , const VkFence* pFences -- > , VkBool32 waitAll -- > , uint64_t timeout -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkWaitForFences vkWaitForFences registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myWaitForFences <- vkGetDeviceProc @VkWaitForFences vkDevice -- -- or less efficient: -- -- > myWaitForFences <- vkGetProc @VkWaitForFences -- -- __Note:__ @vkWaitForFencesUnsafe@ and @vkWaitForFencesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkWaitForFences@ is an alias -- of @vkWaitForFencesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkWaitForFencesSafe@. -- vkWaitForFences :: VkDevice -- ^ device -> Word32 -- ^ fenceCount -> Ptr VkFence -- ^ pFences -> VkBool32 -- ^ waitAll -> Word64 -- ^ timeout -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkWaitForFences = vkWaitForFencesUnsafe #else vkWaitForFences = vkWaitForFencesSafe #endif {-# INLINE vkWaitForFences #-} -- | Success codes: 'VK_SUCCESS', 'VK_TIMEOUT'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkWaitForFences -- > ( VkDevice device -- > , uint32_t fenceCount -- > , const VkFence* pFences -- > , VkBool32 waitAll -- > , uint64_t timeout -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkWaitForFences vkWaitForFences registry at www.khronos.org> type HS_vkWaitForFences = VkDevice -- ^ device -> Word32 -- ^ fenceCount -> Ptr VkFence -- ^ pFences -> VkBool32 -- ^ waitAll -> Word64 -- ^ timeout -> IO VkResult type PFN_vkWaitForFences = FunPtr HS_vkWaitForFences foreign import ccall unsafe "dynamic" unwrapVkWaitForFencesUnsafe :: PFN_vkWaitForFences -> HS_vkWaitForFences foreign import ccall safe "dynamic" unwrapVkWaitForFencesSafe :: PFN_vkWaitForFences -> HS_vkWaitForFences instance VulkanProc "vkWaitForFences" where type VkProcType "vkWaitForFences" = HS_vkWaitForFences vkProcSymbol = _VkWaitForFences {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkWaitForFencesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkWaitForFencesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreateSemaphore :: CString pattern VkCreateSemaphore <- (is_VkCreateSemaphore -> True) where VkCreateSemaphore = _VkCreateSemaphore {-# INLINE _VkCreateSemaphore #-} _VkCreateSemaphore :: CString _VkCreateSemaphore = Ptr "vkCreateSemaphore\NUL"# {-# INLINE is_VkCreateSemaphore #-} is_VkCreateSemaphore :: CString -> Bool is_VkCreateSemaphore = (EQ ==) . cmpCStrings _VkCreateSemaphore type VkCreateSemaphore = "vkCreateSemaphore" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateSemaphore -- > ( VkDevice device -- > , const VkSemaphoreCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkSemaphore* pSemaphore -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateSemaphore vkCreateSemaphore registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateSemaphore <- vkGetDeviceProc @VkCreateSemaphore vkDevice -- -- or less efficient: -- -- > myCreateSemaphore <- vkGetProc @VkCreateSemaphore -- -- __Note:__ @vkCreateSemaphoreUnsafe@ and @vkCreateSemaphoreSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateSemaphore@ is an alias -- of @vkCreateSemaphoreUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateSemaphoreSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateSemaphore" vkCreateSemaphoreUnsafe :: VkDevice -- ^ device -> Ptr VkSemaphoreCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkSemaphore -- ^ pSemaphore -> IO VkResult #else vkCreateSemaphoreUnsafe :: VkDevice -- ^ device -> Ptr VkSemaphoreCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkSemaphore -- ^ pSemaphore -> IO VkResult vkCreateSemaphoreUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateSemaphore) {-# NOINLINE vkCreateSemaphoreUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateSemaphore -- > ( VkDevice device -- > , const VkSemaphoreCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkSemaphore* pSemaphore -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateSemaphore vkCreateSemaphore registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateSemaphore <- vkGetDeviceProc @VkCreateSemaphore vkDevice -- -- or less efficient: -- -- > myCreateSemaphore <- vkGetProc @VkCreateSemaphore -- -- __Note:__ @vkCreateSemaphoreUnsafe@ and @vkCreateSemaphoreSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateSemaphore@ is an alias -- of @vkCreateSemaphoreUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateSemaphoreSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateSemaphore" vkCreateSemaphoreSafe :: VkDevice -- ^ device -> Ptr VkSemaphoreCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkSemaphore -- ^ pSemaphore -> IO VkResult #else vkCreateSemaphoreSafe :: VkDevice -- ^ device -> Ptr VkSemaphoreCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkSemaphore -- ^ pSemaphore -> IO VkResult vkCreateSemaphoreSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateSemaphore) {-# NOINLINE vkCreateSemaphoreSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateSemaphore -- > ( VkDevice device -- > , const VkSemaphoreCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkSemaphore* pSemaphore -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateSemaphore vkCreateSemaphore registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateSemaphore <- vkGetDeviceProc @VkCreateSemaphore vkDevice -- -- or less efficient: -- -- > myCreateSemaphore <- vkGetProc @VkCreateSemaphore -- -- __Note:__ @vkCreateSemaphoreUnsafe@ and @vkCreateSemaphoreSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateSemaphore@ is an alias -- of @vkCreateSemaphoreUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateSemaphoreSafe@. -- vkCreateSemaphore :: VkDevice -- ^ device -> Ptr VkSemaphoreCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkSemaphore -- ^ pSemaphore -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateSemaphore = vkCreateSemaphoreUnsafe #else vkCreateSemaphore = vkCreateSemaphoreSafe #endif {-# INLINE vkCreateSemaphore #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateSemaphore -- > ( VkDevice device -- > , const VkSemaphoreCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkSemaphore* pSemaphore -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateSemaphore vkCreateSemaphore registry at www.khronos.org> type HS_vkCreateSemaphore = VkDevice -- ^ device -> Ptr VkSemaphoreCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkSemaphore -- ^ pSemaphore -> IO VkResult type PFN_vkCreateSemaphore = FunPtr HS_vkCreateSemaphore foreign import ccall unsafe "dynamic" unwrapVkCreateSemaphoreUnsafe :: PFN_vkCreateSemaphore -> HS_vkCreateSemaphore foreign import ccall safe "dynamic" unwrapVkCreateSemaphoreSafe :: PFN_vkCreateSemaphore -> HS_vkCreateSemaphore instance VulkanProc "vkCreateSemaphore" where type VkProcType "vkCreateSemaphore" = HS_vkCreateSemaphore vkProcSymbol = _VkCreateSemaphore {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateSemaphoreUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateSemaphoreSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroySemaphore :: CString pattern VkDestroySemaphore <- (is_VkDestroySemaphore -> True) where VkDestroySemaphore = _VkDestroySemaphore {-# INLINE _VkDestroySemaphore #-} _VkDestroySemaphore :: CString _VkDestroySemaphore = Ptr "vkDestroySemaphore\NUL"# {-# INLINE is_VkDestroySemaphore #-} is_VkDestroySemaphore :: CString -> Bool is_VkDestroySemaphore = (EQ ==) . cmpCStrings _VkDestroySemaphore type VkDestroySemaphore = "vkDestroySemaphore" -- | -- > void vkDestroySemaphore -- > ( VkDevice device -- > , VkSemaphore semaphore -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroySemaphore vkDestroySemaphore registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroySemaphore <- vkGetDeviceProc @VkDestroySemaphore vkDevice -- -- or less efficient: -- -- > myDestroySemaphore <- vkGetProc @VkDestroySemaphore -- -- __Note:__ @vkDestroySemaphoreUnsafe@ and @vkDestroySemaphoreSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroySemaphore@ is an alias -- of @vkDestroySemaphoreUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroySemaphoreSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroySemaphore" vkDestroySemaphoreUnsafe :: VkDevice -- ^ device -> VkSemaphore -- ^ semaphore -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroySemaphoreUnsafe :: VkDevice -- ^ device -> VkSemaphore -- ^ semaphore -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroySemaphoreUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroySemaphore) {-# NOINLINE vkDestroySemaphoreUnsafe #-} #endif -- | -- > void vkDestroySemaphore -- > ( VkDevice device -- > , VkSemaphore semaphore -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroySemaphore vkDestroySemaphore registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroySemaphore <- vkGetDeviceProc @VkDestroySemaphore vkDevice -- -- or less efficient: -- -- > myDestroySemaphore <- vkGetProc @VkDestroySemaphore -- -- __Note:__ @vkDestroySemaphoreUnsafe@ and @vkDestroySemaphoreSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroySemaphore@ is an alias -- of @vkDestroySemaphoreUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroySemaphoreSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroySemaphore" vkDestroySemaphoreSafe :: VkDevice -- ^ device -> VkSemaphore -- ^ semaphore -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroySemaphoreSafe :: VkDevice -- ^ device -> VkSemaphore -- ^ semaphore -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroySemaphoreSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroySemaphore) {-# NOINLINE vkDestroySemaphoreSafe #-} #endif -- | -- > void vkDestroySemaphore -- > ( VkDevice device -- > , VkSemaphore semaphore -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroySemaphore vkDestroySemaphore registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroySemaphore <- vkGetDeviceProc @VkDestroySemaphore vkDevice -- -- or less efficient: -- -- > myDestroySemaphore <- vkGetProc @VkDestroySemaphore -- -- __Note:__ @vkDestroySemaphoreUnsafe@ and @vkDestroySemaphoreSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroySemaphore@ is an alias -- of @vkDestroySemaphoreUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroySemaphoreSafe@. -- vkDestroySemaphore :: VkDevice -- ^ device -> VkSemaphore -- ^ semaphore -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroySemaphore = vkDestroySemaphoreUnsafe #else vkDestroySemaphore = vkDestroySemaphoreSafe #endif {-# INLINE vkDestroySemaphore #-} -- | > void vkDestroySemaphore -- > ( VkDevice device -- > , VkSemaphore semaphore -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroySemaphore vkDestroySemaphore registry at www.khronos.org> type HS_vkDestroySemaphore = VkDevice -- ^ device -> VkSemaphore -- ^ semaphore -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroySemaphore = FunPtr HS_vkDestroySemaphore foreign import ccall unsafe "dynamic" unwrapVkDestroySemaphoreUnsafe :: PFN_vkDestroySemaphore -> HS_vkDestroySemaphore foreign import ccall safe "dynamic" unwrapVkDestroySemaphoreSafe :: PFN_vkDestroySemaphore -> HS_vkDestroySemaphore instance VulkanProc "vkDestroySemaphore" where type VkProcType "vkDestroySemaphore" = HS_vkDestroySemaphore vkProcSymbol = _VkDestroySemaphore {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroySemaphoreUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroySemaphoreSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreateEvent :: CString pattern VkCreateEvent <- (is_VkCreateEvent -> True) where VkCreateEvent = _VkCreateEvent {-# INLINE _VkCreateEvent #-} _VkCreateEvent :: CString _VkCreateEvent = Ptr "vkCreateEvent\NUL"# {-# INLINE is_VkCreateEvent #-} is_VkCreateEvent :: CString -> Bool is_VkCreateEvent = (EQ ==) . cmpCStrings _VkCreateEvent type VkCreateEvent = "vkCreateEvent" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateEvent -- > ( VkDevice device -- > , const VkEventCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkEvent* pEvent -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateEvent vkCreateEvent registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateEvent <- vkGetDeviceProc @VkCreateEvent vkDevice -- -- or less efficient: -- -- > myCreateEvent <- vkGetProc @VkCreateEvent -- -- __Note:__ @vkCreateEventUnsafe@ and @vkCreateEventSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateEvent@ is an alias -- of @vkCreateEventUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateEventSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateEvent" vkCreateEventUnsafe :: VkDevice -- ^ device -> Ptr VkEventCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkEvent -- ^ pEvent -> IO VkResult #else vkCreateEventUnsafe :: VkDevice -- ^ device -> Ptr VkEventCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkEvent -- ^ pEvent -> IO VkResult vkCreateEventUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateEvent) {-# NOINLINE vkCreateEventUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateEvent -- > ( VkDevice device -- > , const VkEventCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkEvent* pEvent -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateEvent vkCreateEvent registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateEvent <- vkGetDeviceProc @VkCreateEvent vkDevice -- -- or less efficient: -- -- > myCreateEvent <- vkGetProc @VkCreateEvent -- -- __Note:__ @vkCreateEventUnsafe@ and @vkCreateEventSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateEvent@ is an alias -- of @vkCreateEventUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateEventSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateEvent" vkCreateEventSafe :: VkDevice -- ^ device -> Ptr VkEventCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkEvent -- ^ pEvent -> IO VkResult #else vkCreateEventSafe :: VkDevice -- ^ device -> Ptr VkEventCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkEvent -- ^ pEvent -> IO VkResult vkCreateEventSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateEvent) {-# NOINLINE vkCreateEventSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateEvent -- > ( VkDevice device -- > , const VkEventCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkEvent* pEvent -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateEvent vkCreateEvent registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateEvent <- vkGetDeviceProc @VkCreateEvent vkDevice -- -- or less efficient: -- -- > myCreateEvent <- vkGetProc @VkCreateEvent -- -- __Note:__ @vkCreateEventUnsafe@ and @vkCreateEventSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateEvent@ is an alias -- of @vkCreateEventUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateEventSafe@. -- vkCreateEvent :: VkDevice -- ^ device -> Ptr VkEventCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkEvent -- ^ pEvent -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateEvent = vkCreateEventUnsafe #else vkCreateEvent = vkCreateEventSafe #endif {-# INLINE vkCreateEvent #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateEvent -- > ( VkDevice device -- > , const VkEventCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkEvent* pEvent -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateEvent vkCreateEvent registry at www.khronos.org> type HS_vkCreateEvent = VkDevice -- ^ device -> Ptr VkEventCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkEvent -- ^ pEvent -> IO VkResult type PFN_vkCreateEvent = FunPtr HS_vkCreateEvent foreign import ccall unsafe "dynamic" unwrapVkCreateEventUnsafe :: PFN_vkCreateEvent -> HS_vkCreateEvent foreign import ccall safe "dynamic" unwrapVkCreateEventSafe :: PFN_vkCreateEvent -> HS_vkCreateEvent instance VulkanProc "vkCreateEvent" where type VkProcType "vkCreateEvent" = HS_vkCreateEvent vkProcSymbol = _VkCreateEvent {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateEventUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateEventSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroyEvent :: CString pattern VkDestroyEvent <- (is_VkDestroyEvent -> True) where VkDestroyEvent = _VkDestroyEvent {-# INLINE _VkDestroyEvent #-} _VkDestroyEvent :: CString _VkDestroyEvent = Ptr "vkDestroyEvent\NUL"# {-# INLINE is_VkDestroyEvent #-} is_VkDestroyEvent :: CString -> Bool is_VkDestroyEvent = (EQ ==) . cmpCStrings _VkDestroyEvent type VkDestroyEvent = "vkDestroyEvent" -- | -- > void vkDestroyEvent -- > ( VkDevice device -- > , VkEvent event -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyEvent vkDestroyEvent registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyEvent <- vkGetDeviceProc @VkDestroyEvent vkDevice -- -- or less efficient: -- -- > myDestroyEvent <- vkGetProc @VkDestroyEvent -- -- __Note:__ @vkDestroyEventUnsafe@ and @vkDestroyEventSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyEvent@ is an alias -- of @vkDestroyEventUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyEventSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroyEvent" vkDestroyEventUnsafe :: VkDevice -- ^ device -> VkEvent -- ^ event -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyEventUnsafe :: VkDevice -- ^ device -> VkEvent -- ^ event -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyEventUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroyEvent) {-# NOINLINE vkDestroyEventUnsafe #-} #endif -- | -- > void vkDestroyEvent -- > ( VkDevice device -- > , VkEvent event -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyEvent vkDestroyEvent registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyEvent <- vkGetDeviceProc @VkDestroyEvent vkDevice -- -- or less efficient: -- -- > myDestroyEvent <- vkGetProc @VkDestroyEvent -- -- __Note:__ @vkDestroyEventUnsafe@ and @vkDestroyEventSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyEvent@ is an alias -- of @vkDestroyEventUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyEventSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroyEvent" vkDestroyEventSafe :: VkDevice -- ^ device -> VkEvent -- ^ event -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyEventSafe :: VkDevice -- ^ device -> VkEvent -- ^ event -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyEventSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroyEvent) {-# NOINLINE vkDestroyEventSafe #-} #endif -- | -- > void vkDestroyEvent -- > ( VkDevice device -- > , VkEvent event -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyEvent vkDestroyEvent registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyEvent <- vkGetDeviceProc @VkDestroyEvent vkDevice -- -- or less efficient: -- -- > myDestroyEvent <- vkGetProc @VkDestroyEvent -- -- __Note:__ @vkDestroyEventUnsafe@ and @vkDestroyEventSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyEvent@ is an alias -- of @vkDestroyEventUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyEventSafe@. -- vkDestroyEvent :: VkDevice -- ^ device -> VkEvent -- ^ event -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroyEvent = vkDestroyEventUnsafe #else vkDestroyEvent = vkDestroyEventSafe #endif {-# INLINE vkDestroyEvent #-} -- | > void vkDestroyEvent -- > ( VkDevice device -- > , VkEvent event -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyEvent vkDestroyEvent registry at www.khronos.org> type HS_vkDestroyEvent = VkDevice -- ^ device -> VkEvent -- ^ event -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroyEvent = FunPtr HS_vkDestroyEvent foreign import ccall unsafe "dynamic" unwrapVkDestroyEventUnsafe :: PFN_vkDestroyEvent -> HS_vkDestroyEvent foreign import ccall safe "dynamic" unwrapVkDestroyEventSafe :: PFN_vkDestroyEvent -> HS_vkDestroyEvent instance VulkanProc "vkDestroyEvent" where type VkProcType "vkDestroyEvent" = HS_vkDestroyEvent vkProcSymbol = _VkDestroyEvent {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroyEventUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroyEventSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetEventStatus :: CString pattern VkGetEventStatus <- (is_VkGetEventStatus -> True) where VkGetEventStatus = _VkGetEventStatus {-# INLINE _VkGetEventStatus #-} _VkGetEventStatus :: CString _VkGetEventStatus = Ptr "vkGetEventStatus\NUL"# {-# INLINE is_VkGetEventStatus #-} is_VkGetEventStatus :: CString -> Bool is_VkGetEventStatus = (EQ ==) . cmpCStrings _VkGetEventStatus type VkGetEventStatus = "vkGetEventStatus" -- | -- Success codes: 'VK_EVENT_SET', 'VK_EVENT_RESET'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkGetEventStatus -- > ( VkDevice device -- > , VkEvent event -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetEventStatus vkGetEventStatus registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetEventStatus <- vkGetDeviceProc @VkGetEventStatus vkDevice -- -- or less efficient: -- -- > myGetEventStatus <- vkGetProc @VkGetEventStatus -- -- __Note:__ @vkGetEventStatusUnsafe@ and @vkGetEventStatusSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetEventStatus@ is an alias -- of @vkGetEventStatusUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetEventStatusSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetEventStatus" vkGetEventStatusUnsafe :: VkDevice -- ^ device -> VkEvent -- ^ event -> IO VkResult #else vkGetEventStatusUnsafe :: VkDevice -- ^ device -> VkEvent -- ^ event -> IO VkResult vkGetEventStatusUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetEventStatus) {-# NOINLINE vkGetEventStatusUnsafe #-} #endif -- | -- Success codes: 'VK_EVENT_SET', 'VK_EVENT_RESET'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkGetEventStatus -- > ( VkDevice device -- > , VkEvent event -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetEventStatus vkGetEventStatus registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetEventStatus <- vkGetDeviceProc @VkGetEventStatus vkDevice -- -- or less efficient: -- -- > myGetEventStatus <- vkGetProc @VkGetEventStatus -- -- __Note:__ @vkGetEventStatusUnsafe@ and @vkGetEventStatusSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetEventStatus@ is an alias -- of @vkGetEventStatusUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetEventStatusSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetEventStatus" vkGetEventStatusSafe :: VkDevice -- ^ device -> VkEvent -- ^ event -> IO VkResult #else vkGetEventStatusSafe :: VkDevice -- ^ device -> VkEvent -- ^ event -> IO VkResult vkGetEventStatusSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetEventStatus) {-# NOINLINE vkGetEventStatusSafe #-} #endif -- | -- Success codes: 'VK_EVENT_SET', 'VK_EVENT_RESET'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkGetEventStatus -- > ( VkDevice device -- > , VkEvent event -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetEventStatus vkGetEventStatus registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetEventStatus <- vkGetDeviceProc @VkGetEventStatus vkDevice -- -- or less efficient: -- -- > myGetEventStatus <- vkGetProc @VkGetEventStatus -- -- __Note:__ @vkGetEventStatusUnsafe@ and @vkGetEventStatusSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetEventStatus@ is an alias -- of @vkGetEventStatusUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetEventStatusSafe@. -- vkGetEventStatus :: VkDevice -- ^ device -> VkEvent -- ^ event -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkGetEventStatus = vkGetEventStatusUnsafe #else vkGetEventStatus = vkGetEventStatusSafe #endif {-# INLINE vkGetEventStatus #-} -- | Success codes: 'VK_EVENT_SET', 'VK_EVENT_RESET'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkGetEventStatus -- > ( VkDevice device -- > , VkEvent event -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetEventStatus vkGetEventStatus registry at www.khronos.org> type HS_vkGetEventStatus = VkDevice -- ^ device -> VkEvent -- ^ event -> IO VkResult type PFN_vkGetEventStatus = FunPtr HS_vkGetEventStatus foreign import ccall unsafe "dynamic" unwrapVkGetEventStatusUnsafe :: PFN_vkGetEventStatus -> HS_vkGetEventStatus foreign import ccall safe "dynamic" unwrapVkGetEventStatusSafe :: PFN_vkGetEventStatus -> HS_vkGetEventStatus instance VulkanProc "vkGetEventStatus" where type VkProcType "vkGetEventStatus" = HS_vkGetEventStatus vkProcSymbol = _VkGetEventStatus {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetEventStatusUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetEventStatusSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkSetEvent :: CString pattern VkSetEvent <- (is_VkSetEvent -> True) where VkSetEvent = _VkSetEvent {-# INLINE _VkSetEvent #-} _VkSetEvent :: CString _VkSetEvent = Ptr "vkSetEvent\NUL"# {-# INLINE is_VkSetEvent #-} is_VkSetEvent :: CString -> Bool is_VkSetEvent = (EQ ==) . cmpCStrings _VkSetEvent type VkSetEvent = "vkSetEvent" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkSetEvent -- > ( VkDevice device -- > , VkEvent event -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkSetEvent vkSetEvent registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > mySetEvent <- vkGetDeviceProc @VkSetEvent vkDevice -- -- or less efficient: -- -- > mySetEvent <- vkGetProc @VkSetEvent -- -- __Note:__ @vkSetEventUnsafe@ and @vkSetEventSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkSetEvent@ is an alias -- of @vkSetEventUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkSetEventSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkSetEvent" vkSetEventUnsafe :: VkDevice -- ^ device -> VkEvent -- ^ event -> IO VkResult #else vkSetEventUnsafe :: VkDevice -- ^ device -> VkEvent -- ^ event -> IO VkResult vkSetEventUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkSetEvent) {-# NOINLINE vkSetEventUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkSetEvent -- > ( VkDevice device -- > , VkEvent event -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkSetEvent vkSetEvent registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > mySetEvent <- vkGetDeviceProc @VkSetEvent vkDevice -- -- or less efficient: -- -- > mySetEvent <- vkGetProc @VkSetEvent -- -- __Note:__ @vkSetEventUnsafe@ and @vkSetEventSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkSetEvent@ is an alias -- of @vkSetEventUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkSetEventSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkSetEvent" vkSetEventSafe :: VkDevice -- ^ device -> VkEvent -- ^ event -> IO VkResult #else vkSetEventSafe :: VkDevice -- ^ device -> VkEvent -- ^ event -> IO VkResult vkSetEventSafe = unsafeDupablePerformIO (vkGetProcSafe @VkSetEvent) {-# NOINLINE vkSetEventSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkSetEvent -- > ( VkDevice device -- > , VkEvent event -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkSetEvent vkSetEvent registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > mySetEvent <- vkGetDeviceProc @VkSetEvent vkDevice -- -- or less efficient: -- -- > mySetEvent <- vkGetProc @VkSetEvent -- -- __Note:__ @vkSetEventUnsafe@ and @vkSetEventSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkSetEvent@ is an alias -- of @vkSetEventUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkSetEventSafe@. -- vkSetEvent :: VkDevice -- ^ device -> VkEvent -- ^ event -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkSetEvent = vkSetEventUnsafe #else vkSetEvent = vkSetEventSafe #endif {-# INLINE vkSetEvent #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkSetEvent -- > ( VkDevice device -- > , VkEvent event -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkSetEvent vkSetEvent registry at www.khronos.org> type HS_vkSetEvent = VkDevice -- ^ device -> VkEvent -- ^ event -> IO VkResult type PFN_vkSetEvent = FunPtr HS_vkSetEvent foreign import ccall unsafe "dynamic" unwrapVkSetEventUnsafe :: PFN_vkSetEvent -> HS_vkSetEvent foreign import ccall safe "dynamic" unwrapVkSetEventSafe :: PFN_vkSetEvent -> HS_vkSetEvent instance VulkanProc "vkSetEvent" where type VkProcType "vkSetEvent" = HS_vkSetEvent vkProcSymbol = _VkSetEvent {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkSetEventUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkSetEventSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkResetEvent :: CString pattern VkResetEvent <- (is_VkResetEvent -> True) where VkResetEvent = _VkResetEvent {-# INLINE _VkResetEvent #-} _VkResetEvent :: CString _VkResetEvent = Ptr "vkResetEvent\NUL"# {-# INLINE is_VkResetEvent #-} is_VkResetEvent :: CString -> Bool is_VkResetEvent = (EQ ==) . cmpCStrings _VkResetEvent type VkResetEvent = "vkResetEvent" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkResetEvent -- > ( VkDevice device -- > , VkEvent event -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetEvent vkResetEvent registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myResetEvent <- vkGetDeviceProc @VkResetEvent vkDevice -- -- or less efficient: -- -- > myResetEvent <- vkGetProc @VkResetEvent -- -- __Note:__ @vkResetEventUnsafe@ and @vkResetEventSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkResetEvent@ is an alias -- of @vkResetEventUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkResetEventSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkResetEvent" vkResetEventUnsafe :: VkDevice -- ^ device -> VkEvent -- ^ event -> IO VkResult #else vkResetEventUnsafe :: VkDevice -- ^ device -> VkEvent -- ^ event -> IO VkResult vkResetEventUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkResetEvent) {-# NOINLINE vkResetEventUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkResetEvent -- > ( VkDevice device -- > , VkEvent event -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetEvent vkResetEvent registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myResetEvent <- vkGetDeviceProc @VkResetEvent vkDevice -- -- or less efficient: -- -- > myResetEvent <- vkGetProc @VkResetEvent -- -- __Note:__ @vkResetEventUnsafe@ and @vkResetEventSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkResetEvent@ is an alias -- of @vkResetEventUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkResetEventSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkResetEvent" vkResetEventSafe :: VkDevice -- ^ device -> VkEvent -- ^ event -> IO VkResult #else vkResetEventSafe :: VkDevice -- ^ device -> VkEvent -- ^ event -> IO VkResult vkResetEventSafe = unsafeDupablePerformIO (vkGetProcSafe @VkResetEvent) {-# NOINLINE vkResetEventSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkResetEvent -- > ( VkDevice device -- > , VkEvent event -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetEvent vkResetEvent registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myResetEvent <- vkGetDeviceProc @VkResetEvent vkDevice -- -- or less efficient: -- -- > myResetEvent <- vkGetProc @VkResetEvent -- -- __Note:__ @vkResetEventUnsafe@ and @vkResetEventSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkResetEvent@ is an alias -- of @vkResetEventUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkResetEventSafe@. -- vkResetEvent :: VkDevice -- ^ device -> VkEvent -- ^ event -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkResetEvent = vkResetEventUnsafe #else vkResetEvent = vkResetEventSafe #endif {-# INLINE vkResetEvent #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkResetEvent -- > ( VkDevice device -- > , VkEvent event -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetEvent vkResetEvent registry at www.khronos.org> type HS_vkResetEvent = VkDevice -- ^ device -> VkEvent -- ^ event -> IO VkResult type PFN_vkResetEvent = FunPtr HS_vkResetEvent foreign import ccall unsafe "dynamic" unwrapVkResetEventUnsafe :: PFN_vkResetEvent -> HS_vkResetEvent foreign import ccall safe "dynamic" unwrapVkResetEventSafe :: PFN_vkResetEvent -> HS_vkResetEvent instance VulkanProc "vkResetEvent" where type VkProcType "vkResetEvent" = HS_vkResetEvent vkProcSymbol = _VkResetEvent {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkResetEventUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkResetEventSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreateQueryPool :: CString pattern VkCreateQueryPool <- (is_VkCreateQueryPool -> True) where VkCreateQueryPool = _VkCreateQueryPool {-# INLINE _VkCreateQueryPool #-} _VkCreateQueryPool :: CString _VkCreateQueryPool = Ptr "vkCreateQueryPool\NUL"# {-# INLINE is_VkCreateQueryPool #-} is_VkCreateQueryPool :: CString -> Bool is_VkCreateQueryPool = (EQ ==) . cmpCStrings _VkCreateQueryPool type VkCreateQueryPool = "vkCreateQueryPool" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateQueryPool -- > ( VkDevice device -- > , const VkQueryPoolCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkQueryPool* pQueryPool -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateQueryPool vkCreateQueryPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateQueryPool <- vkGetDeviceProc @VkCreateQueryPool vkDevice -- -- or less efficient: -- -- > myCreateQueryPool <- vkGetProc @VkCreateQueryPool -- -- __Note:__ @vkCreateQueryPoolUnsafe@ and @vkCreateQueryPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateQueryPool@ is an alias -- of @vkCreateQueryPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateQueryPoolSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateQueryPool" vkCreateQueryPoolUnsafe :: VkDevice -- ^ device -> Ptr VkQueryPoolCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkQueryPool -- ^ pQueryPool -> IO VkResult #else vkCreateQueryPoolUnsafe :: VkDevice -- ^ device -> Ptr VkQueryPoolCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkQueryPool -- ^ pQueryPool -> IO VkResult vkCreateQueryPoolUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateQueryPool) {-# NOINLINE vkCreateQueryPoolUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateQueryPool -- > ( VkDevice device -- > , const VkQueryPoolCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkQueryPool* pQueryPool -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateQueryPool vkCreateQueryPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateQueryPool <- vkGetDeviceProc @VkCreateQueryPool vkDevice -- -- or less efficient: -- -- > myCreateQueryPool <- vkGetProc @VkCreateQueryPool -- -- __Note:__ @vkCreateQueryPoolUnsafe@ and @vkCreateQueryPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateQueryPool@ is an alias -- of @vkCreateQueryPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateQueryPoolSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateQueryPool" vkCreateQueryPoolSafe :: VkDevice -- ^ device -> Ptr VkQueryPoolCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkQueryPool -- ^ pQueryPool -> IO VkResult #else vkCreateQueryPoolSafe :: VkDevice -- ^ device -> Ptr VkQueryPoolCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkQueryPool -- ^ pQueryPool -> IO VkResult vkCreateQueryPoolSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateQueryPool) {-# NOINLINE vkCreateQueryPoolSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateQueryPool -- > ( VkDevice device -- > , const VkQueryPoolCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkQueryPool* pQueryPool -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateQueryPool vkCreateQueryPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateQueryPool <- vkGetDeviceProc @VkCreateQueryPool vkDevice -- -- or less efficient: -- -- > myCreateQueryPool <- vkGetProc @VkCreateQueryPool -- -- __Note:__ @vkCreateQueryPoolUnsafe@ and @vkCreateQueryPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateQueryPool@ is an alias -- of @vkCreateQueryPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateQueryPoolSafe@. -- vkCreateQueryPool :: VkDevice -- ^ device -> Ptr VkQueryPoolCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkQueryPool -- ^ pQueryPool -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateQueryPool = vkCreateQueryPoolUnsafe #else vkCreateQueryPool = vkCreateQueryPoolSafe #endif {-# INLINE vkCreateQueryPool #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateQueryPool -- > ( VkDevice device -- > , const VkQueryPoolCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkQueryPool* pQueryPool -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateQueryPool vkCreateQueryPool registry at www.khronos.org> type HS_vkCreateQueryPool = VkDevice -- ^ device -> Ptr VkQueryPoolCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkQueryPool -- ^ pQueryPool -> IO VkResult type PFN_vkCreateQueryPool = FunPtr HS_vkCreateQueryPool foreign import ccall unsafe "dynamic" unwrapVkCreateQueryPoolUnsafe :: PFN_vkCreateQueryPool -> HS_vkCreateQueryPool foreign import ccall safe "dynamic" unwrapVkCreateQueryPoolSafe :: PFN_vkCreateQueryPool -> HS_vkCreateQueryPool instance VulkanProc "vkCreateQueryPool" where type VkProcType "vkCreateQueryPool" = HS_vkCreateQueryPool vkProcSymbol = _VkCreateQueryPool {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateQueryPoolUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateQueryPoolSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroyQueryPool :: CString pattern VkDestroyQueryPool <- (is_VkDestroyQueryPool -> True) where VkDestroyQueryPool = _VkDestroyQueryPool {-# INLINE _VkDestroyQueryPool #-} _VkDestroyQueryPool :: CString _VkDestroyQueryPool = Ptr "vkDestroyQueryPool\NUL"# {-# INLINE is_VkDestroyQueryPool #-} is_VkDestroyQueryPool :: CString -> Bool is_VkDestroyQueryPool = (EQ ==) . cmpCStrings _VkDestroyQueryPool type VkDestroyQueryPool = "vkDestroyQueryPool" -- | -- > void vkDestroyQueryPool -- > ( VkDevice device -- > , VkQueryPool queryPool -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyQueryPool vkDestroyQueryPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyQueryPool <- vkGetDeviceProc @VkDestroyQueryPool vkDevice -- -- or less efficient: -- -- > myDestroyQueryPool <- vkGetProc @VkDestroyQueryPool -- -- __Note:__ @vkDestroyQueryPoolUnsafe@ and @vkDestroyQueryPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyQueryPool@ is an alias -- of @vkDestroyQueryPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyQueryPoolSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroyQueryPool" vkDestroyQueryPoolUnsafe :: VkDevice -- ^ device -> VkQueryPool -- ^ queryPool -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyQueryPoolUnsafe :: VkDevice -- ^ device -> VkQueryPool -- ^ queryPool -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyQueryPoolUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroyQueryPool) {-# NOINLINE vkDestroyQueryPoolUnsafe #-} #endif -- | -- > void vkDestroyQueryPool -- > ( VkDevice device -- > , VkQueryPool queryPool -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyQueryPool vkDestroyQueryPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyQueryPool <- vkGetDeviceProc @VkDestroyQueryPool vkDevice -- -- or less efficient: -- -- > myDestroyQueryPool <- vkGetProc @VkDestroyQueryPool -- -- __Note:__ @vkDestroyQueryPoolUnsafe@ and @vkDestroyQueryPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyQueryPool@ is an alias -- of @vkDestroyQueryPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyQueryPoolSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroyQueryPool" vkDestroyQueryPoolSafe :: VkDevice -- ^ device -> VkQueryPool -- ^ queryPool -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyQueryPoolSafe :: VkDevice -- ^ device -> VkQueryPool -- ^ queryPool -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyQueryPoolSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroyQueryPool) {-# NOINLINE vkDestroyQueryPoolSafe #-} #endif -- | -- > void vkDestroyQueryPool -- > ( VkDevice device -- > , VkQueryPool queryPool -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyQueryPool vkDestroyQueryPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyQueryPool <- vkGetDeviceProc @VkDestroyQueryPool vkDevice -- -- or less efficient: -- -- > myDestroyQueryPool <- vkGetProc @VkDestroyQueryPool -- -- __Note:__ @vkDestroyQueryPoolUnsafe@ and @vkDestroyQueryPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyQueryPool@ is an alias -- of @vkDestroyQueryPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyQueryPoolSafe@. -- vkDestroyQueryPool :: VkDevice -- ^ device -> VkQueryPool -- ^ queryPool -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroyQueryPool = vkDestroyQueryPoolUnsafe #else vkDestroyQueryPool = vkDestroyQueryPoolSafe #endif {-# INLINE vkDestroyQueryPool #-} -- | > void vkDestroyQueryPool -- > ( VkDevice device -- > , VkQueryPool queryPool -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyQueryPool vkDestroyQueryPool registry at www.khronos.org> type HS_vkDestroyQueryPool = VkDevice -- ^ device -> VkQueryPool -- ^ queryPool -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroyQueryPool = FunPtr HS_vkDestroyQueryPool foreign import ccall unsafe "dynamic" unwrapVkDestroyQueryPoolUnsafe :: PFN_vkDestroyQueryPool -> HS_vkDestroyQueryPool foreign import ccall safe "dynamic" unwrapVkDestroyQueryPoolSafe :: PFN_vkDestroyQueryPool -> HS_vkDestroyQueryPool instance VulkanProc "vkDestroyQueryPool" where type VkProcType "vkDestroyQueryPool" = HS_vkDestroyQueryPool vkProcSymbol = _VkDestroyQueryPool {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroyQueryPoolUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroyQueryPoolSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetQueryPoolResults :: CString pattern VkGetQueryPoolResults <- (is_VkGetQueryPoolResults -> True) where VkGetQueryPoolResults = _VkGetQueryPoolResults {-# INLINE _VkGetQueryPoolResults #-} _VkGetQueryPoolResults :: CString _VkGetQueryPoolResults = Ptr "vkGetQueryPoolResults\NUL"# {-# INLINE is_VkGetQueryPoolResults #-} is_VkGetQueryPoolResults :: CString -> Bool is_VkGetQueryPoolResults = (EQ ==) . cmpCStrings _VkGetQueryPoolResults type VkGetQueryPoolResults = "vkGetQueryPoolResults" -- | -- Success codes: 'VK_SUCCESS', 'VK_NOT_READY'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkGetQueryPoolResults -- > ( VkDevice device -- > , VkQueryPool queryPool -- > , uint32_t firstQuery -- > , uint32_t queryCount -- > , size_t dataSize -- > , void* pData -- > , VkDeviceSize stride -- > , VkQueryResultFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetQueryPoolResults vkGetQueryPoolResults registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetQueryPoolResults <- vkGetDeviceProc @VkGetQueryPoolResults vkDevice -- -- or less efficient: -- -- > myGetQueryPoolResults <- vkGetProc @VkGetQueryPoolResults -- -- __Note:__ @vkGetQueryPoolResultsUnsafe@ and @vkGetQueryPoolResultsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetQueryPoolResults@ is an alias -- of @vkGetQueryPoolResultsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetQueryPoolResultsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetQueryPoolResults" vkGetQueryPoolResultsUnsafe :: VkDevice -- ^ device -> VkQueryPool -- ^ queryPool -> Word32 -- ^ firstQuery -> Word32 -- ^ queryCount -> CSize -- ^ dataSize -> Ptr Void -- ^ pData -> VkDeviceSize -- ^ stride -> VkQueryResultFlags -- ^ flags -> IO VkResult #else vkGetQueryPoolResultsUnsafe :: VkDevice -- ^ device -> VkQueryPool -- ^ queryPool -> Word32 -- ^ firstQuery -> Word32 -- ^ queryCount -> CSize -- ^ dataSize -> Ptr Void -- ^ pData -> VkDeviceSize -- ^ stride -> VkQueryResultFlags -- ^ flags -> IO VkResult vkGetQueryPoolResultsUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetQueryPoolResults) {-# NOINLINE vkGetQueryPoolResultsUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_NOT_READY'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkGetQueryPoolResults -- > ( VkDevice device -- > , VkQueryPool queryPool -- > , uint32_t firstQuery -- > , uint32_t queryCount -- > , size_t dataSize -- > , void* pData -- > , VkDeviceSize stride -- > , VkQueryResultFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetQueryPoolResults vkGetQueryPoolResults registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetQueryPoolResults <- vkGetDeviceProc @VkGetQueryPoolResults vkDevice -- -- or less efficient: -- -- > myGetQueryPoolResults <- vkGetProc @VkGetQueryPoolResults -- -- __Note:__ @vkGetQueryPoolResultsUnsafe@ and @vkGetQueryPoolResultsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetQueryPoolResults@ is an alias -- of @vkGetQueryPoolResultsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetQueryPoolResultsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetQueryPoolResults" vkGetQueryPoolResultsSafe :: VkDevice -- ^ device -> VkQueryPool -- ^ queryPool -> Word32 -- ^ firstQuery -> Word32 -- ^ queryCount -> CSize -- ^ dataSize -> Ptr Void -- ^ pData -> VkDeviceSize -- ^ stride -> VkQueryResultFlags -- ^ flags -> IO VkResult #else vkGetQueryPoolResultsSafe :: VkDevice -- ^ device -> VkQueryPool -- ^ queryPool -> Word32 -- ^ firstQuery -> Word32 -- ^ queryCount -> CSize -- ^ dataSize -> Ptr Void -- ^ pData -> VkDeviceSize -- ^ stride -> VkQueryResultFlags -- ^ flags -> IO VkResult vkGetQueryPoolResultsSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetQueryPoolResults) {-# NOINLINE vkGetQueryPoolResultsSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_NOT_READY'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkGetQueryPoolResults -- > ( VkDevice device -- > , VkQueryPool queryPool -- > , uint32_t firstQuery -- > , uint32_t queryCount -- > , size_t dataSize -- > , void* pData -- > , VkDeviceSize stride -- > , VkQueryResultFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetQueryPoolResults vkGetQueryPoolResults registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetQueryPoolResults <- vkGetDeviceProc @VkGetQueryPoolResults vkDevice -- -- or less efficient: -- -- > myGetQueryPoolResults <- vkGetProc @VkGetQueryPoolResults -- -- __Note:__ @vkGetQueryPoolResultsUnsafe@ and @vkGetQueryPoolResultsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetQueryPoolResults@ is an alias -- of @vkGetQueryPoolResultsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetQueryPoolResultsSafe@. -- vkGetQueryPoolResults :: VkDevice -- ^ device -> VkQueryPool -- ^ queryPool -> Word32 -- ^ firstQuery -> Word32 -- ^ queryCount -> CSize -- ^ dataSize -> Ptr Void -- ^ pData -> VkDeviceSize -- ^ stride -> VkQueryResultFlags -- ^ flags -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkGetQueryPoolResults = vkGetQueryPoolResultsUnsafe #else vkGetQueryPoolResults = vkGetQueryPoolResultsSafe #endif {-# INLINE vkGetQueryPoolResults #-} -- | Success codes: 'VK_SUCCESS', 'VK_NOT_READY'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. -- -- > VkResult vkGetQueryPoolResults -- > ( VkDevice device -- > , VkQueryPool queryPool -- > , uint32_t firstQuery -- > , uint32_t queryCount -- > , size_t dataSize -- > , void* pData -- > , VkDeviceSize stride -- > , VkQueryResultFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetQueryPoolResults vkGetQueryPoolResults registry at www.khronos.org> type HS_vkGetQueryPoolResults = VkDevice -- ^ device -> VkQueryPool -- ^ queryPool -> Word32 -- ^ firstQuery -> Word32 -- ^ queryCount -> CSize -- ^ dataSize -> Ptr Void -- ^ pData -> VkDeviceSize -- ^ stride -> VkQueryResultFlags -- ^ flags -> IO VkResult type PFN_vkGetQueryPoolResults = FunPtr HS_vkGetQueryPoolResults foreign import ccall unsafe "dynamic" unwrapVkGetQueryPoolResultsUnsafe :: PFN_vkGetQueryPoolResults -> HS_vkGetQueryPoolResults foreign import ccall safe "dynamic" unwrapVkGetQueryPoolResultsSafe :: PFN_vkGetQueryPoolResults -> HS_vkGetQueryPoolResults instance VulkanProc "vkGetQueryPoolResults" where type VkProcType "vkGetQueryPoolResults" = HS_vkGetQueryPoolResults vkProcSymbol = _VkGetQueryPoolResults {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetQueryPoolResultsUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetQueryPoolResultsSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreateBuffer :: CString pattern VkCreateBuffer <- (is_VkCreateBuffer -> True) where VkCreateBuffer = _VkCreateBuffer {-# INLINE _VkCreateBuffer #-} _VkCreateBuffer :: CString _VkCreateBuffer = Ptr "vkCreateBuffer\NUL"# {-# INLINE is_VkCreateBuffer #-} is_VkCreateBuffer :: CString -> Bool is_VkCreateBuffer = (EQ ==) . cmpCStrings _VkCreateBuffer type VkCreateBuffer = "vkCreateBuffer" -- | -- 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 vkCreateBuffer -- > ( VkDevice device -- > , const VkBufferCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkBuffer* pBuffer -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateBuffer vkCreateBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateBuffer <- vkGetDeviceProc @VkCreateBuffer vkDevice -- -- or less efficient: -- -- > myCreateBuffer <- vkGetProc @VkCreateBuffer -- -- __Note:__ @vkCreateBufferUnsafe@ and @vkCreateBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateBuffer@ is an alias -- of @vkCreateBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateBuffer" vkCreateBufferUnsafe :: VkDevice -- ^ device -> Ptr VkBufferCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkBuffer -- ^ pBuffer -> IO VkResult #else vkCreateBufferUnsafe :: VkDevice -- ^ device -> Ptr VkBufferCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkBuffer -- ^ pBuffer -> IO VkResult vkCreateBufferUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateBuffer) {-# NOINLINE vkCreateBufferUnsafe #-} #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 vkCreateBuffer -- > ( VkDevice device -- > , const VkBufferCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkBuffer* pBuffer -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateBuffer vkCreateBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateBuffer <- vkGetDeviceProc @VkCreateBuffer vkDevice -- -- or less efficient: -- -- > myCreateBuffer <- vkGetProc @VkCreateBuffer -- -- __Note:__ @vkCreateBufferUnsafe@ and @vkCreateBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateBuffer@ is an alias -- of @vkCreateBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateBuffer" vkCreateBufferSafe :: VkDevice -- ^ device -> Ptr VkBufferCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkBuffer -- ^ pBuffer -> IO VkResult #else vkCreateBufferSafe :: VkDevice -- ^ device -> Ptr VkBufferCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkBuffer -- ^ pBuffer -> IO VkResult vkCreateBufferSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateBuffer) {-# NOINLINE vkCreateBufferSafe #-} #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 vkCreateBuffer -- > ( VkDevice device -- > , const VkBufferCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkBuffer* pBuffer -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateBuffer vkCreateBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateBuffer <- vkGetDeviceProc @VkCreateBuffer vkDevice -- -- or less efficient: -- -- > myCreateBuffer <- vkGetProc @VkCreateBuffer -- -- __Note:__ @vkCreateBufferUnsafe@ and @vkCreateBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateBuffer@ is an alias -- of @vkCreateBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateBufferSafe@. -- vkCreateBuffer :: VkDevice -- ^ device -> Ptr VkBufferCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkBuffer -- ^ pBuffer -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateBuffer = vkCreateBufferUnsafe #else vkCreateBuffer = vkCreateBufferSafe #endif {-# INLINE vkCreateBuffer #-} -- | 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 vkCreateBuffer -- > ( VkDevice device -- > , const VkBufferCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkBuffer* pBuffer -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateBuffer vkCreateBuffer registry at www.khronos.org> type HS_vkCreateBuffer = VkDevice -- ^ device -> Ptr VkBufferCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkBuffer -- ^ pBuffer -> IO VkResult type PFN_vkCreateBuffer = FunPtr HS_vkCreateBuffer foreign import ccall unsafe "dynamic" unwrapVkCreateBufferUnsafe :: PFN_vkCreateBuffer -> HS_vkCreateBuffer foreign import ccall safe "dynamic" unwrapVkCreateBufferSafe :: PFN_vkCreateBuffer -> HS_vkCreateBuffer instance VulkanProc "vkCreateBuffer" where type VkProcType "vkCreateBuffer" = HS_vkCreateBuffer vkProcSymbol = _VkCreateBuffer {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateBufferUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateBufferSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroyBuffer :: CString pattern VkDestroyBuffer <- (is_VkDestroyBuffer -> True) where VkDestroyBuffer = _VkDestroyBuffer {-# INLINE _VkDestroyBuffer #-} _VkDestroyBuffer :: CString _VkDestroyBuffer = Ptr "vkDestroyBuffer\NUL"# {-# INLINE is_VkDestroyBuffer #-} is_VkDestroyBuffer :: CString -> Bool is_VkDestroyBuffer = (EQ ==) . cmpCStrings _VkDestroyBuffer type VkDestroyBuffer = "vkDestroyBuffer" -- | -- > void vkDestroyBuffer -- > ( VkDevice device -- > , VkBuffer buffer -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyBuffer vkDestroyBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyBuffer <- vkGetDeviceProc @VkDestroyBuffer vkDevice -- -- or less efficient: -- -- > myDestroyBuffer <- vkGetProc @VkDestroyBuffer -- -- __Note:__ @vkDestroyBufferUnsafe@ and @vkDestroyBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyBuffer@ is an alias -- of @vkDestroyBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroyBuffer" vkDestroyBufferUnsafe :: VkDevice -- ^ device -> VkBuffer -- ^ buffer -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyBufferUnsafe :: VkDevice -- ^ device -> VkBuffer -- ^ buffer -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyBufferUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroyBuffer) {-# NOINLINE vkDestroyBufferUnsafe #-} #endif -- | -- > void vkDestroyBuffer -- > ( VkDevice device -- > , VkBuffer buffer -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyBuffer vkDestroyBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyBuffer <- vkGetDeviceProc @VkDestroyBuffer vkDevice -- -- or less efficient: -- -- > myDestroyBuffer <- vkGetProc @VkDestroyBuffer -- -- __Note:__ @vkDestroyBufferUnsafe@ and @vkDestroyBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyBuffer@ is an alias -- of @vkDestroyBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroyBuffer" vkDestroyBufferSafe :: VkDevice -- ^ device -> VkBuffer -- ^ buffer -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyBufferSafe :: VkDevice -- ^ device -> VkBuffer -- ^ buffer -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyBufferSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroyBuffer) {-# NOINLINE vkDestroyBufferSafe #-} #endif -- | -- > void vkDestroyBuffer -- > ( VkDevice device -- > , VkBuffer buffer -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyBuffer vkDestroyBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyBuffer <- vkGetDeviceProc @VkDestroyBuffer vkDevice -- -- or less efficient: -- -- > myDestroyBuffer <- vkGetProc @VkDestroyBuffer -- -- __Note:__ @vkDestroyBufferUnsafe@ and @vkDestroyBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyBuffer@ is an alias -- of @vkDestroyBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyBufferSafe@. -- vkDestroyBuffer :: VkDevice -- ^ device -> VkBuffer -- ^ buffer -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroyBuffer = vkDestroyBufferUnsafe #else vkDestroyBuffer = vkDestroyBufferSafe #endif {-# INLINE vkDestroyBuffer #-} -- | > void vkDestroyBuffer -- > ( VkDevice device -- > , VkBuffer buffer -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyBuffer vkDestroyBuffer registry at www.khronos.org> type HS_vkDestroyBuffer = VkDevice -- ^ device -> VkBuffer -- ^ buffer -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroyBuffer = FunPtr HS_vkDestroyBuffer foreign import ccall unsafe "dynamic" unwrapVkDestroyBufferUnsafe :: PFN_vkDestroyBuffer -> HS_vkDestroyBuffer foreign import ccall safe "dynamic" unwrapVkDestroyBufferSafe :: PFN_vkDestroyBuffer -> HS_vkDestroyBuffer instance VulkanProc "vkDestroyBuffer" where type VkProcType "vkDestroyBuffer" = HS_vkDestroyBuffer vkProcSymbol = _VkDestroyBuffer {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroyBufferUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroyBufferSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreateBufferView :: CString pattern VkCreateBufferView <- (is_VkCreateBufferView -> True) where VkCreateBufferView = _VkCreateBufferView {-# INLINE _VkCreateBufferView #-} _VkCreateBufferView :: CString _VkCreateBufferView = Ptr "vkCreateBufferView\NUL"# {-# INLINE is_VkCreateBufferView #-} is_VkCreateBufferView :: CString -> Bool is_VkCreateBufferView = (EQ ==) . cmpCStrings _VkCreateBufferView type VkCreateBufferView = "vkCreateBufferView" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateBufferView -- > ( VkDevice device -- > , const VkBufferViewCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkBufferView* pView -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateBufferView vkCreateBufferView registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateBufferView <- vkGetDeviceProc @VkCreateBufferView vkDevice -- -- or less efficient: -- -- > myCreateBufferView <- vkGetProc @VkCreateBufferView -- -- __Note:__ @vkCreateBufferViewUnsafe@ and @vkCreateBufferViewSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateBufferView@ is an alias -- of @vkCreateBufferViewUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateBufferViewSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateBufferView" vkCreateBufferViewUnsafe :: VkDevice -- ^ device -> Ptr VkBufferViewCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkBufferView -- ^ pView -> IO VkResult #else vkCreateBufferViewUnsafe :: VkDevice -- ^ device -> Ptr VkBufferViewCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkBufferView -- ^ pView -> IO VkResult vkCreateBufferViewUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateBufferView) {-# NOINLINE vkCreateBufferViewUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateBufferView -- > ( VkDevice device -- > , const VkBufferViewCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkBufferView* pView -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateBufferView vkCreateBufferView registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateBufferView <- vkGetDeviceProc @VkCreateBufferView vkDevice -- -- or less efficient: -- -- > myCreateBufferView <- vkGetProc @VkCreateBufferView -- -- __Note:__ @vkCreateBufferViewUnsafe@ and @vkCreateBufferViewSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateBufferView@ is an alias -- of @vkCreateBufferViewUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateBufferViewSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateBufferView" vkCreateBufferViewSafe :: VkDevice -- ^ device -> Ptr VkBufferViewCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkBufferView -- ^ pView -> IO VkResult #else vkCreateBufferViewSafe :: VkDevice -- ^ device -> Ptr VkBufferViewCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkBufferView -- ^ pView -> IO VkResult vkCreateBufferViewSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateBufferView) {-# NOINLINE vkCreateBufferViewSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateBufferView -- > ( VkDevice device -- > , const VkBufferViewCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkBufferView* pView -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateBufferView vkCreateBufferView registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateBufferView <- vkGetDeviceProc @VkCreateBufferView vkDevice -- -- or less efficient: -- -- > myCreateBufferView <- vkGetProc @VkCreateBufferView -- -- __Note:__ @vkCreateBufferViewUnsafe@ and @vkCreateBufferViewSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateBufferView@ is an alias -- of @vkCreateBufferViewUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateBufferViewSafe@. -- vkCreateBufferView :: VkDevice -- ^ device -> Ptr VkBufferViewCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkBufferView -- ^ pView -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateBufferView = vkCreateBufferViewUnsafe #else vkCreateBufferView = vkCreateBufferViewSafe #endif {-# INLINE vkCreateBufferView #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateBufferView -- > ( VkDevice device -- > , const VkBufferViewCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkBufferView* pView -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateBufferView vkCreateBufferView registry at www.khronos.org> type HS_vkCreateBufferView = VkDevice -- ^ device -> Ptr VkBufferViewCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkBufferView -- ^ pView -> IO VkResult type PFN_vkCreateBufferView = FunPtr HS_vkCreateBufferView foreign import ccall unsafe "dynamic" unwrapVkCreateBufferViewUnsafe :: PFN_vkCreateBufferView -> HS_vkCreateBufferView foreign import ccall safe "dynamic" unwrapVkCreateBufferViewSafe :: PFN_vkCreateBufferView -> HS_vkCreateBufferView instance VulkanProc "vkCreateBufferView" where type VkProcType "vkCreateBufferView" = HS_vkCreateBufferView vkProcSymbol = _VkCreateBufferView {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateBufferViewUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateBufferViewSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroyBufferView :: CString pattern VkDestroyBufferView <- (is_VkDestroyBufferView -> True) where VkDestroyBufferView = _VkDestroyBufferView {-# INLINE _VkDestroyBufferView #-} _VkDestroyBufferView :: CString _VkDestroyBufferView = Ptr "vkDestroyBufferView\NUL"# {-# INLINE is_VkDestroyBufferView #-} is_VkDestroyBufferView :: CString -> Bool is_VkDestroyBufferView = (EQ ==) . cmpCStrings _VkDestroyBufferView type VkDestroyBufferView = "vkDestroyBufferView" -- | -- > void vkDestroyBufferView -- > ( VkDevice device -- > , VkBufferView bufferView -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyBufferView vkDestroyBufferView registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyBufferView <- vkGetDeviceProc @VkDestroyBufferView vkDevice -- -- or less efficient: -- -- > myDestroyBufferView <- vkGetProc @VkDestroyBufferView -- -- __Note:__ @vkDestroyBufferViewUnsafe@ and @vkDestroyBufferViewSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyBufferView@ is an alias -- of @vkDestroyBufferViewUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyBufferViewSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroyBufferView" vkDestroyBufferViewUnsafe :: VkDevice -- ^ device -> VkBufferView -- ^ bufferView -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyBufferViewUnsafe :: VkDevice -- ^ device -> VkBufferView -- ^ bufferView -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyBufferViewUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroyBufferView) {-# NOINLINE vkDestroyBufferViewUnsafe #-} #endif -- | -- > void vkDestroyBufferView -- > ( VkDevice device -- > , VkBufferView bufferView -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyBufferView vkDestroyBufferView registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyBufferView <- vkGetDeviceProc @VkDestroyBufferView vkDevice -- -- or less efficient: -- -- > myDestroyBufferView <- vkGetProc @VkDestroyBufferView -- -- __Note:__ @vkDestroyBufferViewUnsafe@ and @vkDestroyBufferViewSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyBufferView@ is an alias -- of @vkDestroyBufferViewUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyBufferViewSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroyBufferView" vkDestroyBufferViewSafe :: VkDevice -- ^ device -> VkBufferView -- ^ bufferView -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyBufferViewSafe :: VkDevice -- ^ device -> VkBufferView -- ^ bufferView -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyBufferViewSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroyBufferView) {-# NOINLINE vkDestroyBufferViewSafe #-} #endif -- | -- > void vkDestroyBufferView -- > ( VkDevice device -- > , VkBufferView bufferView -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyBufferView vkDestroyBufferView registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyBufferView <- vkGetDeviceProc @VkDestroyBufferView vkDevice -- -- or less efficient: -- -- > myDestroyBufferView <- vkGetProc @VkDestroyBufferView -- -- __Note:__ @vkDestroyBufferViewUnsafe@ and @vkDestroyBufferViewSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyBufferView@ is an alias -- of @vkDestroyBufferViewUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyBufferViewSafe@. -- vkDestroyBufferView :: VkDevice -- ^ device -> VkBufferView -- ^ bufferView -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroyBufferView = vkDestroyBufferViewUnsafe #else vkDestroyBufferView = vkDestroyBufferViewSafe #endif {-# INLINE vkDestroyBufferView #-} -- | > void vkDestroyBufferView -- > ( VkDevice device -- > , VkBufferView bufferView -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyBufferView vkDestroyBufferView registry at www.khronos.org> type HS_vkDestroyBufferView = VkDevice -- ^ device -> VkBufferView -- ^ bufferView -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroyBufferView = FunPtr HS_vkDestroyBufferView foreign import ccall unsafe "dynamic" unwrapVkDestroyBufferViewUnsafe :: PFN_vkDestroyBufferView -> HS_vkDestroyBufferView foreign import ccall safe "dynamic" unwrapVkDestroyBufferViewSafe :: PFN_vkDestroyBufferView -> HS_vkDestroyBufferView instance VulkanProc "vkDestroyBufferView" where type VkProcType "vkDestroyBufferView" = HS_vkDestroyBufferView vkProcSymbol = _VkDestroyBufferView {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroyBufferViewUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroyBufferViewSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreateImage :: CString pattern VkCreateImage <- (is_VkCreateImage -> True) where VkCreateImage = _VkCreateImage {-# INLINE _VkCreateImage #-} _VkCreateImage :: CString _VkCreateImage = Ptr "vkCreateImage\NUL"# {-# INLINE is_VkCreateImage #-} is_VkCreateImage :: CString -> Bool is_VkCreateImage = (EQ ==) . cmpCStrings _VkCreateImage type VkCreateImage = "vkCreateImage" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateImage -- > ( VkDevice device -- > , const VkImageCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkImage* pImage -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateImage vkCreateImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateImage <- vkGetDeviceProc @VkCreateImage vkDevice -- -- or less efficient: -- -- > myCreateImage <- vkGetProc @VkCreateImage -- -- __Note:__ @vkCreateImageUnsafe@ and @vkCreateImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateImage@ is an alias -- of @vkCreateImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateImageSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateImage" vkCreateImageUnsafe :: VkDevice -- ^ device -> Ptr VkImageCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkImage -- ^ pImage -> IO VkResult #else vkCreateImageUnsafe :: VkDevice -- ^ device -> Ptr VkImageCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkImage -- ^ pImage -> IO VkResult vkCreateImageUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateImage) {-# NOINLINE vkCreateImageUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateImage -- > ( VkDevice device -- > , const VkImageCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkImage* pImage -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateImage vkCreateImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateImage <- vkGetDeviceProc @VkCreateImage vkDevice -- -- or less efficient: -- -- > myCreateImage <- vkGetProc @VkCreateImage -- -- __Note:__ @vkCreateImageUnsafe@ and @vkCreateImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateImage@ is an alias -- of @vkCreateImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateImageSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateImage" vkCreateImageSafe :: VkDevice -- ^ device -> Ptr VkImageCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkImage -- ^ pImage -> IO VkResult #else vkCreateImageSafe :: VkDevice -- ^ device -> Ptr VkImageCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkImage -- ^ pImage -> IO VkResult vkCreateImageSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateImage) {-# NOINLINE vkCreateImageSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateImage -- > ( VkDevice device -- > , const VkImageCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkImage* pImage -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateImage vkCreateImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateImage <- vkGetDeviceProc @VkCreateImage vkDevice -- -- or less efficient: -- -- > myCreateImage <- vkGetProc @VkCreateImage -- -- __Note:__ @vkCreateImageUnsafe@ and @vkCreateImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateImage@ is an alias -- of @vkCreateImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateImageSafe@. -- vkCreateImage :: VkDevice -- ^ device -> Ptr VkImageCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkImage -- ^ pImage -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateImage = vkCreateImageUnsafe #else vkCreateImage = vkCreateImageSafe #endif {-# INLINE vkCreateImage #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateImage -- > ( VkDevice device -- > , const VkImageCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkImage* pImage -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateImage vkCreateImage registry at www.khronos.org> type HS_vkCreateImage = VkDevice -- ^ device -> Ptr VkImageCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkImage -- ^ pImage -> IO VkResult type PFN_vkCreateImage = FunPtr HS_vkCreateImage foreign import ccall unsafe "dynamic" unwrapVkCreateImageUnsafe :: PFN_vkCreateImage -> HS_vkCreateImage foreign import ccall safe "dynamic" unwrapVkCreateImageSafe :: PFN_vkCreateImage -> HS_vkCreateImage instance VulkanProc "vkCreateImage" where type VkProcType "vkCreateImage" = HS_vkCreateImage vkProcSymbol = _VkCreateImage {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateImageUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateImageSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroyImage :: CString pattern VkDestroyImage <- (is_VkDestroyImage -> True) where VkDestroyImage = _VkDestroyImage {-# INLINE _VkDestroyImage #-} _VkDestroyImage :: CString _VkDestroyImage = Ptr "vkDestroyImage\NUL"# {-# INLINE is_VkDestroyImage #-} is_VkDestroyImage :: CString -> Bool is_VkDestroyImage = (EQ ==) . cmpCStrings _VkDestroyImage type VkDestroyImage = "vkDestroyImage" -- | -- > void vkDestroyImage -- > ( VkDevice device -- > , VkImage image -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyImage vkDestroyImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyImage <- vkGetDeviceProc @VkDestroyImage vkDevice -- -- or less efficient: -- -- > myDestroyImage <- vkGetProc @VkDestroyImage -- -- __Note:__ @vkDestroyImageUnsafe@ and @vkDestroyImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyImage@ is an alias -- of @vkDestroyImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyImageSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroyImage" vkDestroyImageUnsafe :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyImageUnsafe :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyImageUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroyImage) {-# NOINLINE vkDestroyImageUnsafe #-} #endif -- | -- > void vkDestroyImage -- > ( VkDevice device -- > , VkImage image -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyImage vkDestroyImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyImage <- vkGetDeviceProc @VkDestroyImage vkDevice -- -- or less efficient: -- -- > myDestroyImage <- vkGetProc @VkDestroyImage -- -- __Note:__ @vkDestroyImageUnsafe@ and @vkDestroyImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyImage@ is an alias -- of @vkDestroyImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyImageSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroyImage" vkDestroyImageSafe :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyImageSafe :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyImageSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroyImage) {-# NOINLINE vkDestroyImageSafe #-} #endif -- | -- > void vkDestroyImage -- > ( VkDevice device -- > , VkImage image -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyImage vkDestroyImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyImage <- vkGetDeviceProc @VkDestroyImage vkDevice -- -- or less efficient: -- -- > myDestroyImage <- vkGetProc @VkDestroyImage -- -- __Note:__ @vkDestroyImageUnsafe@ and @vkDestroyImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyImage@ is an alias -- of @vkDestroyImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyImageSafe@. -- vkDestroyImage :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroyImage = vkDestroyImageUnsafe #else vkDestroyImage = vkDestroyImageSafe #endif {-# INLINE vkDestroyImage #-} -- | > void vkDestroyImage -- > ( VkDevice device -- > , VkImage image -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyImage vkDestroyImage registry at www.khronos.org> type HS_vkDestroyImage = VkDevice -- ^ device -> VkImage -- ^ image -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroyImage = FunPtr HS_vkDestroyImage foreign import ccall unsafe "dynamic" unwrapVkDestroyImageUnsafe :: PFN_vkDestroyImage -> HS_vkDestroyImage foreign import ccall safe "dynamic" unwrapVkDestroyImageSafe :: PFN_vkDestroyImage -> HS_vkDestroyImage instance VulkanProc "vkDestroyImage" where type VkProcType "vkDestroyImage" = HS_vkDestroyImage vkProcSymbol = _VkDestroyImage {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroyImageUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroyImageSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetImageSubresourceLayout :: CString pattern VkGetImageSubresourceLayout <- (is_VkGetImageSubresourceLayout -> True) where VkGetImageSubresourceLayout = _VkGetImageSubresourceLayout {-# INLINE _VkGetImageSubresourceLayout #-} _VkGetImageSubresourceLayout :: CString _VkGetImageSubresourceLayout = Ptr "vkGetImageSubresourceLayout\NUL"# {-# INLINE is_VkGetImageSubresourceLayout #-} is_VkGetImageSubresourceLayout :: CString -> Bool is_VkGetImageSubresourceLayout = (EQ ==) . cmpCStrings _VkGetImageSubresourceLayout type VkGetImageSubresourceLayout = "vkGetImageSubresourceLayout" -- | -- > void vkGetImageSubresourceLayout -- > ( VkDevice device -- > , VkImage image -- > , const VkImageSubresource* pSubresource -- > , VkSubresourceLayout* pLayout -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageSubresourceLayout vkGetImageSubresourceLayout registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetImageSubresourceLayout <- vkGetDeviceProc @VkGetImageSubresourceLayout vkDevice -- -- or less efficient: -- -- > myGetImageSubresourceLayout <- vkGetProc @VkGetImageSubresourceLayout -- -- __Note:__ @vkGetImageSubresourceLayoutUnsafe@ and @vkGetImageSubresourceLayoutSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetImageSubresourceLayout@ is an alias -- of @vkGetImageSubresourceLayoutUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetImageSubresourceLayoutSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetImageSubresourceLayout" vkGetImageSubresourceLayoutUnsafe :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr VkImageSubresource -- ^ pSubresource -> Ptr VkSubresourceLayout -- ^ pLayout -> IO () #else vkGetImageSubresourceLayoutUnsafe :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr VkImageSubresource -- ^ pSubresource -> Ptr VkSubresourceLayout -- ^ pLayout -> IO () vkGetImageSubresourceLayoutUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetImageSubresourceLayout) {-# NOINLINE vkGetImageSubresourceLayoutUnsafe #-} #endif -- | -- > void vkGetImageSubresourceLayout -- > ( VkDevice device -- > , VkImage image -- > , const VkImageSubresource* pSubresource -- > , VkSubresourceLayout* pLayout -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageSubresourceLayout vkGetImageSubresourceLayout registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetImageSubresourceLayout <- vkGetDeviceProc @VkGetImageSubresourceLayout vkDevice -- -- or less efficient: -- -- > myGetImageSubresourceLayout <- vkGetProc @VkGetImageSubresourceLayout -- -- __Note:__ @vkGetImageSubresourceLayoutUnsafe@ and @vkGetImageSubresourceLayoutSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetImageSubresourceLayout@ is an alias -- of @vkGetImageSubresourceLayoutUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetImageSubresourceLayoutSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetImageSubresourceLayout" vkGetImageSubresourceLayoutSafe :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr VkImageSubresource -- ^ pSubresource -> Ptr VkSubresourceLayout -- ^ pLayout -> IO () #else vkGetImageSubresourceLayoutSafe :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr VkImageSubresource -- ^ pSubresource -> Ptr VkSubresourceLayout -- ^ pLayout -> IO () vkGetImageSubresourceLayoutSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetImageSubresourceLayout) {-# NOINLINE vkGetImageSubresourceLayoutSafe #-} #endif -- | -- > void vkGetImageSubresourceLayout -- > ( VkDevice device -- > , VkImage image -- > , const VkImageSubresource* pSubresource -- > , VkSubresourceLayout* pLayout -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageSubresourceLayout vkGetImageSubresourceLayout registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetImageSubresourceLayout <- vkGetDeviceProc @VkGetImageSubresourceLayout vkDevice -- -- or less efficient: -- -- > myGetImageSubresourceLayout <- vkGetProc @VkGetImageSubresourceLayout -- -- __Note:__ @vkGetImageSubresourceLayoutUnsafe@ and @vkGetImageSubresourceLayoutSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetImageSubresourceLayout@ is an alias -- of @vkGetImageSubresourceLayoutUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetImageSubresourceLayoutSafe@. -- vkGetImageSubresourceLayout :: VkDevice -- ^ device -> VkImage -- ^ image -> Ptr VkImageSubresource -- ^ pSubresource -> Ptr VkSubresourceLayout -- ^ pLayout -> IO () #ifdef UNSAFE_FFI_DEFAULT vkGetImageSubresourceLayout = vkGetImageSubresourceLayoutUnsafe #else vkGetImageSubresourceLayout = vkGetImageSubresourceLayoutSafe #endif {-# INLINE vkGetImageSubresourceLayout #-} -- | > void vkGetImageSubresourceLayout -- > ( VkDevice device -- > , VkImage image -- > , const VkImageSubresource* pSubresource -- > , VkSubresourceLayout* pLayout -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetImageSubresourceLayout vkGetImageSubresourceLayout registry at www.khronos.org> type HS_vkGetImageSubresourceLayout = VkDevice -- ^ device -> VkImage -- ^ image -> Ptr VkImageSubresource -- ^ pSubresource -> Ptr VkSubresourceLayout -- ^ pLayout -> IO () type PFN_vkGetImageSubresourceLayout = FunPtr HS_vkGetImageSubresourceLayout foreign import ccall unsafe "dynamic" unwrapVkGetImageSubresourceLayoutUnsafe :: PFN_vkGetImageSubresourceLayout -> HS_vkGetImageSubresourceLayout foreign import ccall safe "dynamic" unwrapVkGetImageSubresourceLayoutSafe :: PFN_vkGetImageSubresourceLayout -> HS_vkGetImageSubresourceLayout instance VulkanProc "vkGetImageSubresourceLayout" where type VkProcType "vkGetImageSubresourceLayout" = HS_vkGetImageSubresourceLayout vkProcSymbol = _VkGetImageSubresourceLayout {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetImageSubresourceLayoutUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetImageSubresourceLayoutSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreateImageView :: CString pattern VkCreateImageView <- (is_VkCreateImageView -> True) where VkCreateImageView = _VkCreateImageView {-# INLINE _VkCreateImageView #-} _VkCreateImageView :: CString _VkCreateImageView = Ptr "vkCreateImageView\NUL"# {-# INLINE is_VkCreateImageView #-} is_VkCreateImageView :: CString -> Bool is_VkCreateImageView = (EQ ==) . cmpCStrings _VkCreateImageView type VkCreateImageView = "vkCreateImageView" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateImageView -- > ( VkDevice device -- > , const VkImageViewCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkImageView* pView -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateImageView vkCreateImageView registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateImageView <- vkGetDeviceProc @VkCreateImageView vkDevice -- -- or less efficient: -- -- > myCreateImageView <- vkGetProc @VkCreateImageView -- -- __Note:__ @vkCreateImageViewUnsafe@ and @vkCreateImageViewSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateImageView@ is an alias -- of @vkCreateImageViewUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateImageViewSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateImageView" vkCreateImageViewUnsafe :: VkDevice -- ^ device -> Ptr VkImageViewCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkImageView -- ^ pView -> IO VkResult #else vkCreateImageViewUnsafe :: VkDevice -- ^ device -> Ptr VkImageViewCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkImageView -- ^ pView -> IO VkResult vkCreateImageViewUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateImageView) {-# NOINLINE vkCreateImageViewUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateImageView -- > ( VkDevice device -- > , const VkImageViewCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkImageView* pView -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateImageView vkCreateImageView registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateImageView <- vkGetDeviceProc @VkCreateImageView vkDevice -- -- or less efficient: -- -- > myCreateImageView <- vkGetProc @VkCreateImageView -- -- __Note:__ @vkCreateImageViewUnsafe@ and @vkCreateImageViewSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateImageView@ is an alias -- of @vkCreateImageViewUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateImageViewSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateImageView" vkCreateImageViewSafe :: VkDevice -- ^ device -> Ptr VkImageViewCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkImageView -- ^ pView -> IO VkResult #else vkCreateImageViewSafe :: VkDevice -- ^ device -> Ptr VkImageViewCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkImageView -- ^ pView -> IO VkResult vkCreateImageViewSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateImageView) {-# NOINLINE vkCreateImageViewSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateImageView -- > ( VkDevice device -- > , const VkImageViewCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkImageView* pView -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateImageView vkCreateImageView registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateImageView <- vkGetDeviceProc @VkCreateImageView vkDevice -- -- or less efficient: -- -- > myCreateImageView <- vkGetProc @VkCreateImageView -- -- __Note:__ @vkCreateImageViewUnsafe@ and @vkCreateImageViewSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateImageView@ is an alias -- of @vkCreateImageViewUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateImageViewSafe@. -- vkCreateImageView :: VkDevice -- ^ device -> Ptr VkImageViewCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkImageView -- ^ pView -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateImageView = vkCreateImageViewUnsafe #else vkCreateImageView = vkCreateImageViewSafe #endif {-# INLINE vkCreateImageView #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateImageView -- > ( VkDevice device -- > , const VkImageViewCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkImageView* pView -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateImageView vkCreateImageView registry at www.khronos.org> type HS_vkCreateImageView = VkDevice -- ^ device -> Ptr VkImageViewCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkImageView -- ^ pView -> IO VkResult type PFN_vkCreateImageView = FunPtr HS_vkCreateImageView foreign import ccall unsafe "dynamic" unwrapVkCreateImageViewUnsafe :: PFN_vkCreateImageView -> HS_vkCreateImageView foreign import ccall safe "dynamic" unwrapVkCreateImageViewSafe :: PFN_vkCreateImageView -> HS_vkCreateImageView instance VulkanProc "vkCreateImageView" where type VkProcType "vkCreateImageView" = HS_vkCreateImageView vkProcSymbol = _VkCreateImageView {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateImageViewUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateImageViewSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroyImageView :: CString pattern VkDestroyImageView <- (is_VkDestroyImageView -> True) where VkDestroyImageView = _VkDestroyImageView {-# INLINE _VkDestroyImageView #-} _VkDestroyImageView :: CString _VkDestroyImageView = Ptr "vkDestroyImageView\NUL"# {-# INLINE is_VkDestroyImageView #-} is_VkDestroyImageView :: CString -> Bool is_VkDestroyImageView = (EQ ==) . cmpCStrings _VkDestroyImageView type VkDestroyImageView = "vkDestroyImageView" -- | -- > void vkDestroyImageView -- > ( VkDevice device -- > , VkImageView imageView -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyImageView vkDestroyImageView registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyImageView <- vkGetDeviceProc @VkDestroyImageView vkDevice -- -- or less efficient: -- -- > myDestroyImageView <- vkGetProc @VkDestroyImageView -- -- __Note:__ @vkDestroyImageViewUnsafe@ and @vkDestroyImageViewSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyImageView@ is an alias -- of @vkDestroyImageViewUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyImageViewSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroyImageView" vkDestroyImageViewUnsafe :: VkDevice -- ^ device -> VkImageView -- ^ imageView -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyImageViewUnsafe :: VkDevice -- ^ device -> VkImageView -- ^ imageView -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyImageViewUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroyImageView) {-# NOINLINE vkDestroyImageViewUnsafe #-} #endif -- | -- > void vkDestroyImageView -- > ( VkDevice device -- > , VkImageView imageView -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyImageView vkDestroyImageView registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyImageView <- vkGetDeviceProc @VkDestroyImageView vkDevice -- -- or less efficient: -- -- > myDestroyImageView <- vkGetProc @VkDestroyImageView -- -- __Note:__ @vkDestroyImageViewUnsafe@ and @vkDestroyImageViewSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyImageView@ is an alias -- of @vkDestroyImageViewUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyImageViewSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroyImageView" vkDestroyImageViewSafe :: VkDevice -- ^ device -> VkImageView -- ^ imageView -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyImageViewSafe :: VkDevice -- ^ device -> VkImageView -- ^ imageView -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyImageViewSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroyImageView) {-# NOINLINE vkDestroyImageViewSafe #-} #endif -- | -- > void vkDestroyImageView -- > ( VkDevice device -- > , VkImageView imageView -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyImageView vkDestroyImageView registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyImageView <- vkGetDeviceProc @VkDestroyImageView vkDevice -- -- or less efficient: -- -- > myDestroyImageView <- vkGetProc @VkDestroyImageView -- -- __Note:__ @vkDestroyImageViewUnsafe@ and @vkDestroyImageViewSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyImageView@ is an alias -- of @vkDestroyImageViewUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyImageViewSafe@. -- vkDestroyImageView :: VkDevice -- ^ device -> VkImageView -- ^ imageView -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroyImageView = vkDestroyImageViewUnsafe #else vkDestroyImageView = vkDestroyImageViewSafe #endif {-# INLINE vkDestroyImageView #-} -- | > void vkDestroyImageView -- > ( VkDevice device -- > , VkImageView imageView -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyImageView vkDestroyImageView registry at www.khronos.org> type HS_vkDestroyImageView = VkDevice -- ^ device -> VkImageView -- ^ imageView -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroyImageView = FunPtr HS_vkDestroyImageView foreign import ccall unsafe "dynamic" unwrapVkDestroyImageViewUnsafe :: PFN_vkDestroyImageView -> HS_vkDestroyImageView foreign import ccall safe "dynamic" unwrapVkDestroyImageViewSafe :: PFN_vkDestroyImageView -> HS_vkDestroyImageView instance VulkanProc "vkDestroyImageView" where type VkProcType "vkDestroyImageView" = HS_vkDestroyImageView vkProcSymbol = _VkDestroyImageView {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroyImageViewUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroyImageViewSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreateShaderModule :: CString pattern VkCreateShaderModule <- (is_VkCreateShaderModule -> True) where VkCreateShaderModule = _VkCreateShaderModule {-# INLINE _VkCreateShaderModule #-} _VkCreateShaderModule :: CString _VkCreateShaderModule = Ptr "vkCreateShaderModule\NUL"# {-# INLINE is_VkCreateShaderModule #-} is_VkCreateShaderModule :: CString -> Bool is_VkCreateShaderModule = (EQ ==) . cmpCStrings _VkCreateShaderModule type VkCreateShaderModule = "vkCreateShaderModule" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_SHADER_NV'. -- -- > VkResult vkCreateShaderModule -- > ( VkDevice device -- > , const VkShaderModuleCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkShaderModule* pShaderModule -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateShaderModule vkCreateShaderModule registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateShaderModule <- vkGetDeviceProc @VkCreateShaderModule vkDevice -- -- or less efficient: -- -- > myCreateShaderModule <- vkGetProc @VkCreateShaderModule -- -- __Note:__ @vkCreateShaderModuleUnsafe@ and @vkCreateShaderModuleSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateShaderModule@ is an alias -- of @vkCreateShaderModuleUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateShaderModuleSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateShaderModule" vkCreateShaderModuleUnsafe :: VkDevice -- ^ device -> Ptr VkShaderModuleCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkShaderModule -- ^ pShaderModule -> IO VkResult #else vkCreateShaderModuleUnsafe :: VkDevice -- ^ device -> Ptr VkShaderModuleCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkShaderModule -- ^ pShaderModule -> IO VkResult vkCreateShaderModuleUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateShaderModule) {-# NOINLINE vkCreateShaderModuleUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_SHADER_NV'. -- -- > VkResult vkCreateShaderModule -- > ( VkDevice device -- > , const VkShaderModuleCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkShaderModule* pShaderModule -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateShaderModule vkCreateShaderModule registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateShaderModule <- vkGetDeviceProc @VkCreateShaderModule vkDevice -- -- or less efficient: -- -- > myCreateShaderModule <- vkGetProc @VkCreateShaderModule -- -- __Note:__ @vkCreateShaderModuleUnsafe@ and @vkCreateShaderModuleSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateShaderModule@ is an alias -- of @vkCreateShaderModuleUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateShaderModuleSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateShaderModule" vkCreateShaderModuleSafe :: VkDevice -- ^ device -> Ptr VkShaderModuleCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkShaderModule -- ^ pShaderModule -> IO VkResult #else vkCreateShaderModuleSafe :: VkDevice -- ^ device -> Ptr VkShaderModuleCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkShaderModule -- ^ pShaderModule -> IO VkResult vkCreateShaderModuleSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateShaderModule) {-# NOINLINE vkCreateShaderModuleSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_SHADER_NV'. -- -- > VkResult vkCreateShaderModule -- > ( VkDevice device -- > , const VkShaderModuleCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkShaderModule* pShaderModule -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateShaderModule vkCreateShaderModule registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateShaderModule <- vkGetDeviceProc @VkCreateShaderModule vkDevice -- -- or less efficient: -- -- > myCreateShaderModule <- vkGetProc @VkCreateShaderModule -- -- __Note:__ @vkCreateShaderModuleUnsafe@ and @vkCreateShaderModuleSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateShaderModule@ is an alias -- of @vkCreateShaderModuleUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateShaderModuleSafe@. -- vkCreateShaderModule :: VkDevice -- ^ device -> Ptr VkShaderModuleCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkShaderModule -- ^ pShaderModule -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateShaderModule = vkCreateShaderModuleUnsafe #else vkCreateShaderModule = vkCreateShaderModuleSafe #endif {-# INLINE vkCreateShaderModule #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_SHADER_NV'. -- -- > VkResult vkCreateShaderModule -- > ( VkDevice device -- > , const VkShaderModuleCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkShaderModule* pShaderModule -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateShaderModule vkCreateShaderModule registry at www.khronos.org> type HS_vkCreateShaderModule = VkDevice -- ^ device -> Ptr VkShaderModuleCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkShaderModule -- ^ pShaderModule -> IO VkResult type PFN_vkCreateShaderModule = FunPtr HS_vkCreateShaderModule foreign import ccall unsafe "dynamic" unwrapVkCreateShaderModuleUnsafe :: PFN_vkCreateShaderModule -> HS_vkCreateShaderModule foreign import ccall safe "dynamic" unwrapVkCreateShaderModuleSafe :: PFN_vkCreateShaderModule -> HS_vkCreateShaderModule instance VulkanProc "vkCreateShaderModule" where type VkProcType "vkCreateShaderModule" = HS_vkCreateShaderModule vkProcSymbol = _VkCreateShaderModule {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateShaderModuleUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateShaderModuleSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroyShaderModule :: CString pattern VkDestroyShaderModule <- (is_VkDestroyShaderModule -> True) where VkDestroyShaderModule = _VkDestroyShaderModule {-# INLINE _VkDestroyShaderModule #-} _VkDestroyShaderModule :: CString _VkDestroyShaderModule = Ptr "vkDestroyShaderModule\NUL"# {-# INLINE is_VkDestroyShaderModule #-} is_VkDestroyShaderModule :: CString -> Bool is_VkDestroyShaderModule = (EQ ==) . cmpCStrings _VkDestroyShaderModule type VkDestroyShaderModule = "vkDestroyShaderModule" -- | -- > void vkDestroyShaderModule -- > ( VkDevice device -- > , VkShaderModule shaderModule -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyShaderModule vkDestroyShaderModule registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyShaderModule <- vkGetDeviceProc @VkDestroyShaderModule vkDevice -- -- or less efficient: -- -- > myDestroyShaderModule <- vkGetProc @VkDestroyShaderModule -- -- __Note:__ @vkDestroyShaderModuleUnsafe@ and @vkDestroyShaderModuleSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyShaderModule@ is an alias -- of @vkDestroyShaderModuleUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyShaderModuleSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroyShaderModule" vkDestroyShaderModuleUnsafe :: VkDevice -- ^ device -> VkShaderModule -- ^ shaderModule -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyShaderModuleUnsafe :: VkDevice -- ^ device -> VkShaderModule -- ^ shaderModule -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyShaderModuleUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroyShaderModule) {-# NOINLINE vkDestroyShaderModuleUnsafe #-} #endif -- | -- > void vkDestroyShaderModule -- > ( VkDevice device -- > , VkShaderModule shaderModule -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyShaderModule vkDestroyShaderModule registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyShaderModule <- vkGetDeviceProc @VkDestroyShaderModule vkDevice -- -- or less efficient: -- -- > myDestroyShaderModule <- vkGetProc @VkDestroyShaderModule -- -- __Note:__ @vkDestroyShaderModuleUnsafe@ and @vkDestroyShaderModuleSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyShaderModule@ is an alias -- of @vkDestroyShaderModuleUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyShaderModuleSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroyShaderModule" vkDestroyShaderModuleSafe :: VkDevice -- ^ device -> VkShaderModule -- ^ shaderModule -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyShaderModuleSafe :: VkDevice -- ^ device -> VkShaderModule -- ^ shaderModule -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyShaderModuleSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroyShaderModule) {-# NOINLINE vkDestroyShaderModuleSafe #-} #endif -- | -- > void vkDestroyShaderModule -- > ( VkDevice device -- > , VkShaderModule shaderModule -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyShaderModule vkDestroyShaderModule registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyShaderModule <- vkGetDeviceProc @VkDestroyShaderModule vkDevice -- -- or less efficient: -- -- > myDestroyShaderModule <- vkGetProc @VkDestroyShaderModule -- -- __Note:__ @vkDestroyShaderModuleUnsafe@ and @vkDestroyShaderModuleSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyShaderModule@ is an alias -- of @vkDestroyShaderModuleUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyShaderModuleSafe@. -- vkDestroyShaderModule :: VkDevice -- ^ device -> VkShaderModule -- ^ shaderModule -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroyShaderModule = vkDestroyShaderModuleUnsafe #else vkDestroyShaderModule = vkDestroyShaderModuleSafe #endif {-# INLINE vkDestroyShaderModule #-} -- | > void vkDestroyShaderModule -- > ( VkDevice device -- > , VkShaderModule shaderModule -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyShaderModule vkDestroyShaderModule registry at www.khronos.org> type HS_vkDestroyShaderModule = VkDevice -- ^ device -> VkShaderModule -- ^ shaderModule -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroyShaderModule = FunPtr HS_vkDestroyShaderModule foreign import ccall unsafe "dynamic" unwrapVkDestroyShaderModuleUnsafe :: PFN_vkDestroyShaderModule -> HS_vkDestroyShaderModule foreign import ccall safe "dynamic" unwrapVkDestroyShaderModuleSafe :: PFN_vkDestroyShaderModule -> HS_vkDestroyShaderModule instance VulkanProc "vkDestroyShaderModule" where type VkProcType "vkDestroyShaderModule" = HS_vkDestroyShaderModule vkProcSymbol = _VkDestroyShaderModule {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroyShaderModuleUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroyShaderModuleSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreatePipelineCache :: CString pattern VkCreatePipelineCache <- (is_VkCreatePipelineCache -> True) where VkCreatePipelineCache = _VkCreatePipelineCache {-# INLINE _VkCreatePipelineCache #-} _VkCreatePipelineCache :: CString _VkCreatePipelineCache = Ptr "vkCreatePipelineCache\NUL"# {-# INLINE is_VkCreatePipelineCache #-} is_VkCreatePipelineCache :: CString -> Bool is_VkCreatePipelineCache = (EQ ==) . cmpCStrings _VkCreatePipelineCache type VkCreatePipelineCache = "vkCreatePipelineCache" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreatePipelineCache -- > ( VkDevice device -- > , const VkPipelineCacheCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkPipelineCache* pPipelineCache -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreatePipelineCache vkCreatePipelineCache registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreatePipelineCache <- vkGetDeviceProc @VkCreatePipelineCache vkDevice -- -- or less efficient: -- -- > myCreatePipelineCache <- vkGetProc @VkCreatePipelineCache -- -- __Note:__ @vkCreatePipelineCacheUnsafe@ and @vkCreatePipelineCacheSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreatePipelineCache@ is an alias -- of @vkCreatePipelineCacheUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreatePipelineCacheSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreatePipelineCache" vkCreatePipelineCacheUnsafe :: VkDevice -- ^ device -> Ptr VkPipelineCacheCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipelineCache -- ^ pPipelineCache -> IO VkResult #else vkCreatePipelineCacheUnsafe :: VkDevice -- ^ device -> Ptr VkPipelineCacheCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipelineCache -- ^ pPipelineCache -> IO VkResult vkCreatePipelineCacheUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreatePipelineCache) {-# NOINLINE vkCreatePipelineCacheUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreatePipelineCache -- > ( VkDevice device -- > , const VkPipelineCacheCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkPipelineCache* pPipelineCache -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreatePipelineCache vkCreatePipelineCache registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreatePipelineCache <- vkGetDeviceProc @VkCreatePipelineCache vkDevice -- -- or less efficient: -- -- > myCreatePipelineCache <- vkGetProc @VkCreatePipelineCache -- -- __Note:__ @vkCreatePipelineCacheUnsafe@ and @vkCreatePipelineCacheSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreatePipelineCache@ is an alias -- of @vkCreatePipelineCacheUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreatePipelineCacheSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreatePipelineCache" vkCreatePipelineCacheSafe :: VkDevice -- ^ device -> Ptr VkPipelineCacheCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipelineCache -- ^ pPipelineCache -> IO VkResult #else vkCreatePipelineCacheSafe :: VkDevice -- ^ device -> Ptr VkPipelineCacheCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipelineCache -- ^ pPipelineCache -> IO VkResult vkCreatePipelineCacheSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreatePipelineCache) {-# NOINLINE vkCreatePipelineCacheSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreatePipelineCache -- > ( VkDevice device -- > , const VkPipelineCacheCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkPipelineCache* pPipelineCache -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreatePipelineCache vkCreatePipelineCache registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreatePipelineCache <- vkGetDeviceProc @VkCreatePipelineCache vkDevice -- -- or less efficient: -- -- > myCreatePipelineCache <- vkGetProc @VkCreatePipelineCache -- -- __Note:__ @vkCreatePipelineCacheUnsafe@ and @vkCreatePipelineCacheSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreatePipelineCache@ is an alias -- of @vkCreatePipelineCacheUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreatePipelineCacheSafe@. -- vkCreatePipelineCache :: VkDevice -- ^ device -> Ptr VkPipelineCacheCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipelineCache -- ^ pPipelineCache -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreatePipelineCache = vkCreatePipelineCacheUnsafe #else vkCreatePipelineCache = vkCreatePipelineCacheSafe #endif {-# INLINE vkCreatePipelineCache #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreatePipelineCache -- > ( VkDevice device -- > , const VkPipelineCacheCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkPipelineCache* pPipelineCache -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreatePipelineCache vkCreatePipelineCache registry at www.khronos.org> type HS_vkCreatePipelineCache = VkDevice -- ^ device -> Ptr VkPipelineCacheCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipelineCache -- ^ pPipelineCache -> IO VkResult type PFN_vkCreatePipelineCache = FunPtr HS_vkCreatePipelineCache foreign import ccall unsafe "dynamic" unwrapVkCreatePipelineCacheUnsafe :: PFN_vkCreatePipelineCache -> HS_vkCreatePipelineCache foreign import ccall safe "dynamic" unwrapVkCreatePipelineCacheSafe :: PFN_vkCreatePipelineCache -> HS_vkCreatePipelineCache instance VulkanProc "vkCreatePipelineCache" where type VkProcType "vkCreatePipelineCache" = HS_vkCreatePipelineCache vkProcSymbol = _VkCreatePipelineCache {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreatePipelineCacheUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreatePipelineCacheSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroyPipelineCache :: CString pattern VkDestroyPipelineCache <- (is_VkDestroyPipelineCache -> True) where VkDestroyPipelineCache = _VkDestroyPipelineCache {-# INLINE _VkDestroyPipelineCache #-} _VkDestroyPipelineCache :: CString _VkDestroyPipelineCache = Ptr "vkDestroyPipelineCache\NUL"# {-# INLINE is_VkDestroyPipelineCache #-} is_VkDestroyPipelineCache :: CString -> Bool is_VkDestroyPipelineCache = (EQ ==) . cmpCStrings _VkDestroyPipelineCache type VkDestroyPipelineCache = "vkDestroyPipelineCache" -- | -- > void vkDestroyPipelineCache -- > ( VkDevice device -- > , VkPipelineCache pipelineCache -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyPipelineCache vkDestroyPipelineCache registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyPipelineCache <- vkGetDeviceProc @VkDestroyPipelineCache vkDevice -- -- or less efficient: -- -- > myDestroyPipelineCache <- vkGetProc @VkDestroyPipelineCache -- -- __Note:__ @vkDestroyPipelineCacheUnsafe@ and @vkDestroyPipelineCacheSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyPipelineCache@ is an alias -- of @vkDestroyPipelineCacheUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyPipelineCacheSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroyPipelineCache" vkDestroyPipelineCacheUnsafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyPipelineCacheUnsafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyPipelineCacheUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroyPipelineCache) {-# NOINLINE vkDestroyPipelineCacheUnsafe #-} #endif -- | -- > void vkDestroyPipelineCache -- > ( VkDevice device -- > , VkPipelineCache pipelineCache -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyPipelineCache vkDestroyPipelineCache registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyPipelineCache <- vkGetDeviceProc @VkDestroyPipelineCache vkDevice -- -- or less efficient: -- -- > myDestroyPipelineCache <- vkGetProc @VkDestroyPipelineCache -- -- __Note:__ @vkDestroyPipelineCacheUnsafe@ and @vkDestroyPipelineCacheSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyPipelineCache@ is an alias -- of @vkDestroyPipelineCacheUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyPipelineCacheSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroyPipelineCache" vkDestroyPipelineCacheSafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyPipelineCacheSafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyPipelineCacheSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroyPipelineCache) {-# NOINLINE vkDestroyPipelineCacheSafe #-} #endif -- | -- > void vkDestroyPipelineCache -- > ( VkDevice device -- > , VkPipelineCache pipelineCache -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyPipelineCache vkDestroyPipelineCache registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyPipelineCache <- vkGetDeviceProc @VkDestroyPipelineCache vkDevice -- -- or less efficient: -- -- > myDestroyPipelineCache <- vkGetProc @VkDestroyPipelineCache -- -- __Note:__ @vkDestroyPipelineCacheUnsafe@ and @vkDestroyPipelineCacheSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyPipelineCache@ is an alias -- of @vkDestroyPipelineCacheUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyPipelineCacheSafe@. -- vkDestroyPipelineCache :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroyPipelineCache = vkDestroyPipelineCacheUnsafe #else vkDestroyPipelineCache = vkDestroyPipelineCacheSafe #endif {-# INLINE vkDestroyPipelineCache #-} -- | > void vkDestroyPipelineCache -- > ( VkDevice device -- > , VkPipelineCache pipelineCache -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyPipelineCache vkDestroyPipelineCache registry at www.khronos.org> type HS_vkDestroyPipelineCache = VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroyPipelineCache = FunPtr HS_vkDestroyPipelineCache foreign import ccall unsafe "dynamic" unwrapVkDestroyPipelineCacheUnsafe :: PFN_vkDestroyPipelineCache -> HS_vkDestroyPipelineCache foreign import ccall safe "dynamic" unwrapVkDestroyPipelineCacheSafe :: PFN_vkDestroyPipelineCache -> HS_vkDestroyPipelineCache instance VulkanProc "vkDestroyPipelineCache" where type VkProcType "vkDestroyPipelineCache" = HS_vkDestroyPipelineCache vkProcSymbol = _VkDestroyPipelineCache {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroyPipelineCacheUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroyPipelineCacheSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetPipelineCacheData :: CString pattern VkGetPipelineCacheData <- (is_VkGetPipelineCacheData -> True) where VkGetPipelineCacheData = _VkGetPipelineCacheData {-# INLINE _VkGetPipelineCacheData #-} _VkGetPipelineCacheData :: CString _VkGetPipelineCacheData = Ptr "vkGetPipelineCacheData\NUL"# {-# INLINE is_VkGetPipelineCacheData #-} is_VkGetPipelineCacheData :: CString -> Bool is_VkGetPipelineCacheData = (EQ ==) . cmpCStrings _VkGetPipelineCacheData type VkGetPipelineCacheData = "vkGetPipelineCacheData" -- | -- Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkGetPipelineCacheData -- > ( VkDevice device -- > , VkPipelineCache pipelineCache -- > , size_t* pDataSize -- > , void* pData -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPipelineCacheData vkGetPipelineCacheData registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPipelineCacheData <- vkGetDeviceProc @VkGetPipelineCacheData vkDevice -- -- or less efficient: -- -- > myGetPipelineCacheData <- vkGetProc @VkGetPipelineCacheData -- -- __Note:__ @vkGetPipelineCacheDataUnsafe@ and @vkGetPipelineCacheDataSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPipelineCacheData@ is an alias -- of @vkGetPipelineCacheDataUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPipelineCacheDataSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetPipelineCacheData" vkGetPipelineCacheDataUnsafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Ptr CSize -- ^ pDataSize -> Ptr Void -- ^ pData -> IO VkResult #else vkGetPipelineCacheDataUnsafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Ptr CSize -- ^ pDataSize -> Ptr Void -- ^ pData -> IO VkResult vkGetPipelineCacheDataUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetPipelineCacheData) {-# NOINLINE vkGetPipelineCacheDataUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkGetPipelineCacheData -- > ( VkDevice device -- > , VkPipelineCache pipelineCache -- > , size_t* pDataSize -- > , void* pData -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPipelineCacheData vkGetPipelineCacheData registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPipelineCacheData <- vkGetDeviceProc @VkGetPipelineCacheData vkDevice -- -- or less efficient: -- -- > myGetPipelineCacheData <- vkGetProc @VkGetPipelineCacheData -- -- __Note:__ @vkGetPipelineCacheDataUnsafe@ and @vkGetPipelineCacheDataSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPipelineCacheData@ is an alias -- of @vkGetPipelineCacheDataUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPipelineCacheDataSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetPipelineCacheData" vkGetPipelineCacheDataSafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Ptr CSize -- ^ pDataSize -> Ptr Void -- ^ pData -> IO VkResult #else vkGetPipelineCacheDataSafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Ptr CSize -- ^ pDataSize -> Ptr Void -- ^ pData -> IO VkResult vkGetPipelineCacheDataSafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetPipelineCacheData) {-# NOINLINE vkGetPipelineCacheDataSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkGetPipelineCacheData -- > ( VkDevice device -- > , VkPipelineCache pipelineCache -- > , size_t* pDataSize -- > , void* pData -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPipelineCacheData vkGetPipelineCacheData registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetPipelineCacheData <- vkGetDeviceProc @VkGetPipelineCacheData vkDevice -- -- or less efficient: -- -- > myGetPipelineCacheData <- vkGetProc @VkGetPipelineCacheData -- -- __Note:__ @vkGetPipelineCacheDataUnsafe@ and @vkGetPipelineCacheDataSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetPipelineCacheData@ is an alias -- of @vkGetPipelineCacheDataUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetPipelineCacheDataSafe@. -- vkGetPipelineCacheData :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Ptr CSize -- ^ pDataSize -> Ptr Void -- ^ pData -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkGetPipelineCacheData = vkGetPipelineCacheDataUnsafe #else vkGetPipelineCacheData = vkGetPipelineCacheDataSafe #endif {-# INLINE vkGetPipelineCacheData #-} -- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkGetPipelineCacheData -- > ( VkDevice device -- > , VkPipelineCache pipelineCache -- > , size_t* pDataSize -- > , void* pData -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetPipelineCacheData vkGetPipelineCacheData registry at www.khronos.org> type HS_vkGetPipelineCacheData = VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Ptr CSize -- ^ pDataSize -> Ptr Void -- ^ pData -> IO VkResult type PFN_vkGetPipelineCacheData = FunPtr HS_vkGetPipelineCacheData foreign import ccall unsafe "dynamic" unwrapVkGetPipelineCacheDataUnsafe :: PFN_vkGetPipelineCacheData -> HS_vkGetPipelineCacheData foreign import ccall safe "dynamic" unwrapVkGetPipelineCacheDataSafe :: PFN_vkGetPipelineCacheData -> HS_vkGetPipelineCacheData instance VulkanProc "vkGetPipelineCacheData" where type VkProcType "vkGetPipelineCacheData" = HS_vkGetPipelineCacheData vkProcSymbol = _VkGetPipelineCacheData {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetPipelineCacheDataUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetPipelineCacheDataSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkMergePipelineCaches :: CString pattern VkMergePipelineCaches <- (is_VkMergePipelineCaches -> True) where VkMergePipelineCaches = _VkMergePipelineCaches {-# INLINE _VkMergePipelineCaches #-} _VkMergePipelineCaches :: CString _VkMergePipelineCaches = Ptr "vkMergePipelineCaches\NUL"# {-# INLINE is_VkMergePipelineCaches #-} is_VkMergePipelineCaches :: CString -> Bool is_VkMergePipelineCaches = (EQ ==) . cmpCStrings _VkMergePipelineCaches type VkMergePipelineCaches = "vkMergePipelineCaches" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkMergePipelineCaches -- > ( VkDevice device -- > , VkPipelineCache dstCache -- > , uint32_t srcCacheCount -- > , const VkPipelineCache* pSrcCaches -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkMergePipelineCaches vkMergePipelineCaches registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myMergePipelineCaches <- vkGetDeviceProc @VkMergePipelineCaches vkDevice -- -- or less efficient: -- -- > myMergePipelineCaches <- vkGetProc @VkMergePipelineCaches -- -- __Note:__ @vkMergePipelineCachesUnsafe@ and @vkMergePipelineCachesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkMergePipelineCaches@ is an alias -- of @vkMergePipelineCachesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkMergePipelineCachesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkMergePipelineCaches" vkMergePipelineCachesUnsafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ dstCache -> Word32 -- ^ srcCacheCount -> Ptr VkPipelineCache -- ^ pSrcCaches -> IO VkResult #else vkMergePipelineCachesUnsafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ dstCache -> Word32 -- ^ srcCacheCount -> Ptr VkPipelineCache -- ^ pSrcCaches -> IO VkResult vkMergePipelineCachesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkMergePipelineCaches) {-# NOINLINE vkMergePipelineCachesUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkMergePipelineCaches -- > ( VkDevice device -- > , VkPipelineCache dstCache -- > , uint32_t srcCacheCount -- > , const VkPipelineCache* pSrcCaches -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkMergePipelineCaches vkMergePipelineCaches registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myMergePipelineCaches <- vkGetDeviceProc @VkMergePipelineCaches vkDevice -- -- or less efficient: -- -- > myMergePipelineCaches <- vkGetProc @VkMergePipelineCaches -- -- __Note:__ @vkMergePipelineCachesUnsafe@ and @vkMergePipelineCachesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkMergePipelineCaches@ is an alias -- of @vkMergePipelineCachesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkMergePipelineCachesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkMergePipelineCaches" vkMergePipelineCachesSafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ dstCache -> Word32 -- ^ srcCacheCount -> Ptr VkPipelineCache -- ^ pSrcCaches -> IO VkResult #else vkMergePipelineCachesSafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ dstCache -> Word32 -- ^ srcCacheCount -> Ptr VkPipelineCache -- ^ pSrcCaches -> IO VkResult vkMergePipelineCachesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkMergePipelineCaches) {-# NOINLINE vkMergePipelineCachesSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkMergePipelineCaches -- > ( VkDevice device -- > , VkPipelineCache dstCache -- > , uint32_t srcCacheCount -- > , const VkPipelineCache* pSrcCaches -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkMergePipelineCaches vkMergePipelineCaches registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myMergePipelineCaches <- vkGetDeviceProc @VkMergePipelineCaches vkDevice -- -- or less efficient: -- -- > myMergePipelineCaches <- vkGetProc @VkMergePipelineCaches -- -- __Note:__ @vkMergePipelineCachesUnsafe@ and @vkMergePipelineCachesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkMergePipelineCaches@ is an alias -- of @vkMergePipelineCachesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkMergePipelineCachesSafe@. -- vkMergePipelineCaches :: VkDevice -- ^ device -> VkPipelineCache -- ^ dstCache -> Word32 -- ^ srcCacheCount -> Ptr VkPipelineCache -- ^ pSrcCaches -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkMergePipelineCaches = vkMergePipelineCachesUnsafe #else vkMergePipelineCaches = vkMergePipelineCachesSafe #endif {-# INLINE vkMergePipelineCaches #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkMergePipelineCaches -- > ( VkDevice device -- > , VkPipelineCache dstCache -- > , uint32_t srcCacheCount -- > , const VkPipelineCache* pSrcCaches -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkMergePipelineCaches vkMergePipelineCaches registry at www.khronos.org> type HS_vkMergePipelineCaches = VkDevice -- ^ device -> VkPipelineCache -- ^ dstCache -> Word32 -- ^ srcCacheCount -> Ptr VkPipelineCache -- ^ pSrcCaches -> IO VkResult type PFN_vkMergePipelineCaches = FunPtr HS_vkMergePipelineCaches foreign import ccall unsafe "dynamic" unwrapVkMergePipelineCachesUnsafe :: PFN_vkMergePipelineCaches -> HS_vkMergePipelineCaches foreign import ccall safe "dynamic" unwrapVkMergePipelineCachesSafe :: PFN_vkMergePipelineCaches -> HS_vkMergePipelineCaches instance VulkanProc "vkMergePipelineCaches" where type VkProcType "vkMergePipelineCaches" = HS_vkMergePipelineCaches vkProcSymbol = _VkMergePipelineCaches {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkMergePipelineCachesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkMergePipelineCachesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreateGraphicsPipelines :: CString pattern VkCreateGraphicsPipelines <- (is_VkCreateGraphicsPipelines -> True) where VkCreateGraphicsPipelines = _VkCreateGraphicsPipelines {-# INLINE _VkCreateGraphicsPipelines #-} _VkCreateGraphicsPipelines :: CString _VkCreateGraphicsPipelines = Ptr "vkCreateGraphicsPipelines\NUL"# {-# INLINE is_VkCreateGraphicsPipelines #-} is_VkCreateGraphicsPipelines :: CString -> Bool is_VkCreateGraphicsPipelines = (EQ ==) . cmpCStrings _VkCreateGraphicsPipelines type VkCreateGraphicsPipelines = "vkCreateGraphicsPipelines" -- | -- Success codes: 'VK_SUCCESS', 'VK_PIPELINE_COMPILE_REQUIRED_EXT'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_SHADER_NV'. -- -- > VkResult vkCreateGraphicsPipelines -- > ( VkDevice device -- > , VkPipelineCache pipelineCache -- > , uint32_t createInfoCount -- > , const VkGraphicsPipelineCreateInfo* pCreateInfos -- > , const VkAllocationCallbacks* pAllocator -- > , VkPipeline* pPipelines -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateGraphicsPipelines vkCreateGraphicsPipelines registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateGraphicsPipelines <- vkGetDeviceProc @VkCreateGraphicsPipelines vkDevice -- -- or less efficient: -- -- > myCreateGraphicsPipelines <- vkGetProc @VkCreateGraphicsPipelines -- -- __Note:__ @vkCreateGraphicsPipelinesUnsafe@ and @vkCreateGraphicsPipelinesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateGraphicsPipelines@ is an alias -- of @vkCreateGraphicsPipelinesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateGraphicsPipelinesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateGraphicsPipelines" vkCreateGraphicsPipelinesUnsafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Word32 -- ^ createInfoCount -> Ptr VkGraphicsPipelineCreateInfo -- ^ pCreateInfos -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipeline -- ^ pPipelines -> IO VkResult #else vkCreateGraphicsPipelinesUnsafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Word32 -- ^ createInfoCount -> Ptr VkGraphicsPipelineCreateInfo -- ^ pCreateInfos -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipeline -- ^ pPipelines -> IO VkResult vkCreateGraphicsPipelinesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateGraphicsPipelines) {-# NOINLINE vkCreateGraphicsPipelinesUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_PIPELINE_COMPILE_REQUIRED_EXT'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_SHADER_NV'. -- -- > VkResult vkCreateGraphicsPipelines -- > ( VkDevice device -- > , VkPipelineCache pipelineCache -- > , uint32_t createInfoCount -- > , const VkGraphicsPipelineCreateInfo* pCreateInfos -- > , const VkAllocationCallbacks* pAllocator -- > , VkPipeline* pPipelines -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateGraphicsPipelines vkCreateGraphicsPipelines registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateGraphicsPipelines <- vkGetDeviceProc @VkCreateGraphicsPipelines vkDevice -- -- or less efficient: -- -- > myCreateGraphicsPipelines <- vkGetProc @VkCreateGraphicsPipelines -- -- __Note:__ @vkCreateGraphicsPipelinesUnsafe@ and @vkCreateGraphicsPipelinesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateGraphicsPipelines@ is an alias -- of @vkCreateGraphicsPipelinesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateGraphicsPipelinesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateGraphicsPipelines" vkCreateGraphicsPipelinesSafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Word32 -- ^ createInfoCount -> Ptr VkGraphicsPipelineCreateInfo -- ^ pCreateInfos -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipeline -- ^ pPipelines -> IO VkResult #else vkCreateGraphicsPipelinesSafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Word32 -- ^ createInfoCount -> Ptr VkGraphicsPipelineCreateInfo -- ^ pCreateInfos -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipeline -- ^ pPipelines -> IO VkResult vkCreateGraphicsPipelinesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateGraphicsPipelines) {-# NOINLINE vkCreateGraphicsPipelinesSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_PIPELINE_COMPILE_REQUIRED_EXT'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_SHADER_NV'. -- -- > VkResult vkCreateGraphicsPipelines -- > ( VkDevice device -- > , VkPipelineCache pipelineCache -- > , uint32_t createInfoCount -- > , const VkGraphicsPipelineCreateInfo* pCreateInfos -- > , const VkAllocationCallbacks* pAllocator -- > , VkPipeline* pPipelines -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateGraphicsPipelines vkCreateGraphicsPipelines registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateGraphicsPipelines <- vkGetDeviceProc @VkCreateGraphicsPipelines vkDevice -- -- or less efficient: -- -- > myCreateGraphicsPipelines <- vkGetProc @VkCreateGraphicsPipelines -- -- __Note:__ @vkCreateGraphicsPipelinesUnsafe@ and @vkCreateGraphicsPipelinesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateGraphicsPipelines@ is an alias -- of @vkCreateGraphicsPipelinesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateGraphicsPipelinesSafe@. -- vkCreateGraphicsPipelines :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Word32 -- ^ createInfoCount -> Ptr VkGraphicsPipelineCreateInfo -- ^ pCreateInfos -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipeline -- ^ pPipelines -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateGraphicsPipelines = vkCreateGraphicsPipelinesUnsafe #else vkCreateGraphicsPipelines = vkCreateGraphicsPipelinesSafe #endif {-# INLINE vkCreateGraphicsPipelines #-} -- | Success codes: 'VK_SUCCESS', 'VK_PIPELINE_COMPILE_REQUIRED_EXT'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_SHADER_NV'. -- -- > VkResult vkCreateGraphicsPipelines -- > ( VkDevice device -- > , VkPipelineCache pipelineCache -- > , uint32_t createInfoCount -- > , const VkGraphicsPipelineCreateInfo* pCreateInfos -- > , const VkAllocationCallbacks* pAllocator -- > , VkPipeline* pPipelines -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateGraphicsPipelines vkCreateGraphicsPipelines registry at www.khronos.org> type HS_vkCreateGraphicsPipelines = VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Word32 -- ^ createInfoCount -> Ptr VkGraphicsPipelineCreateInfo -- ^ pCreateInfos -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipeline -- ^ pPipelines -> IO VkResult type PFN_vkCreateGraphicsPipelines = FunPtr HS_vkCreateGraphicsPipelines foreign import ccall unsafe "dynamic" unwrapVkCreateGraphicsPipelinesUnsafe :: PFN_vkCreateGraphicsPipelines -> HS_vkCreateGraphicsPipelines foreign import ccall safe "dynamic" unwrapVkCreateGraphicsPipelinesSafe :: PFN_vkCreateGraphicsPipelines -> HS_vkCreateGraphicsPipelines instance VulkanProc "vkCreateGraphicsPipelines" where type VkProcType "vkCreateGraphicsPipelines" = HS_vkCreateGraphicsPipelines vkProcSymbol = _VkCreateGraphicsPipelines {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateGraphicsPipelinesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateGraphicsPipelinesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreateComputePipelines :: CString pattern VkCreateComputePipelines <- (is_VkCreateComputePipelines -> True) where VkCreateComputePipelines = _VkCreateComputePipelines {-# INLINE _VkCreateComputePipelines #-} _VkCreateComputePipelines :: CString _VkCreateComputePipelines = Ptr "vkCreateComputePipelines\NUL"# {-# INLINE is_VkCreateComputePipelines #-} is_VkCreateComputePipelines :: CString -> Bool is_VkCreateComputePipelines = (EQ ==) . cmpCStrings _VkCreateComputePipelines type VkCreateComputePipelines = "vkCreateComputePipelines" -- | -- Success codes: 'VK_SUCCESS', 'VK_PIPELINE_COMPILE_REQUIRED_EXT'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_SHADER_NV'. -- -- > VkResult vkCreateComputePipelines -- > ( VkDevice device -- > , VkPipelineCache pipelineCache -- > , uint32_t createInfoCount -- > , const VkComputePipelineCreateInfo* pCreateInfos -- > , const VkAllocationCallbacks* pAllocator -- > , VkPipeline* pPipelines -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateComputePipelines vkCreateComputePipelines registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateComputePipelines <- vkGetDeviceProc @VkCreateComputePipelines vkDevice -- -- or less efficient: -- -- > myCreateComputePipelines <- vkGetProc @VkCreateComputePipelines -- -- __Note:__ @vkCreateComputePipelinesUnsafe@ and @vkCreateComputePipelinesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateComputePipelines@ is an alias -- of @vkCreateComputePipelinesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateComputePipelinesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateComputePipelines" vkCreateComputePipelinesUnsafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Word32 -- ^ createInfoCount -> Ptr VkComputePipelineCreateInfo -- ^ pCreateInfos -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipeline -- ^ pPipelines -> IO VkResult #else vkCreateComputePipelinesUnsafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Word32 -- ^ createInfoCount -> Ptr VkComputePipelineCreateInfo -- ^ pCreateInfos -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipeline -- ^ pPipelines -> IO VkResult vkCreateComputePipelinesUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateComputePipelines) {-# NOINLINE vkCreateComputePipelinesUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_PIPELINE_COMPILE_REQUIRED_EXT'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_SHADER_NV'. -- -- > VkResult vkCreateComputePipelines -- > ( VkDevice device -- > , VkPipelineCache pipelineCache -- > , uint32_t createInfoCount -- > , const VkComputePipelineCreateInfo* pCreateInfos -- > , const VkAllocationCallbacks* pAllocator -- > , VkPipeline* pPipelines -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateComputePipelines vkCreateComputePipelines registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateComputePipelines <- vkGetDeviceProc @VkCreateComputePipelines vkDevice -- -- or less efficient: -- -- > myCreateComputePipelines <- vkGetProc @VkCreateComputePipelines -- -- __Note:__ @vkCreateComputePipelinesUnsafe@ and @vkCreateComputePipelinesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateComputePipelines@ is an alias -- of @vkCreateComputePipelinesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateComputePipelinesSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateComputePipelines" vkCreateComputePipelinesSafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Word32 -- ^ createInfoCount -> Ptr VkComputePipelineCreateInfo -- ^ pCreateInfos -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipeline -- ^ pPipelines -> IO VkResult #else vkCreateComputePipelinesSafe :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Word32 -- ^ createInfoCount -> Ptr VkComputePipelineCreateInfo -- ^ pCreateInfos -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipeline -- ^ pPipelines -> IO VkResult vkCreateComputePipelinesSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateComputePipelines) {-# NOINLINE vkCreateComputePipelinesSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS', 'VK_PIPELINE_COMPILE_REQUIRED_EXT'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_SHADER_NV'. -- -- > VkResult vkCreateComputePipelines -- > ( VkDevice device -- > , VkPipelineCache pipelineCache -- > , uint32_t createInfoCount -- > , const VkComputePipelineCreateInfo* pCreateInfos -- > , const VkAllocationCallbacks* pAllocator -- > , VkPipeline* pPipelines -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateComputePipelines vkCreateComputePipelines registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateComputePipelines <- vkGetDeviceProc @VkCreateComputePipelines vkDevice -- -- or less efficient: -- -- > myCreateComputePipelines <- vkGetProc @VkCreateComputePipelines -- -- __Note:__ @vkCreateComputePipelinesUnsafe@ and @vkCreateComputePipelinesSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateComputePipelines@ is an alias -- of @vkCreateComputePipelinesUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateComputePipelinesSafe@. -- vkCreateComputePipelines :: VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Word32 -- ^ createInfoCount -> Ptr VkComputePipelineCreateInfo -- ^ pCreateInfos -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipeline -- ^ pPipelines -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateComputePipelines = vkCreateComputePipelinesUnsafe #else vkCreateComputePipelines = vkCreateComputePipelinesSafe #endif {-# INLINE vkCreateComputePipelines #-} -- | Success codes: 'VK_SUCCESS', 'VK_PIPELINE_COMPILE_REQUIRED_EXT'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_SHADER_NV'. -- -- > VkResult vkCreateComputePipelines -- > ( VkDevice device -- > , VkPipelineCache pipelineCache -- > , uint32_t createInfoCount -- > , const VkComputePipelineCreateInfo* pCreateInfos -- > , const VkAllocationCallbacks* pAllocator -- > , VkPipeline* pPipelines -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateComputePipelines vkCreateComputePipelines registry at www.khronos.org> type HS_vkCreateComputePipelines = VkDevice -- ^ device -> VkPipelineCache -- ^ pipelineCache -> Word32 -- ^ createInfoCount -> Ptr VkComputePipelineCreateInfo -- ^ pCreateInfos -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipeline -- ^ pPipelines -> IO VkResult type PFN_vkCreateComputePipelines = FunPtr HS_vkCreateComputePipelines foreign import ccall unsafe "dynamic" unwrapVkCreateComputePipelinesUnsafe :: PFN_vkCreateComputePipelines -> HS_vkCreateComputePipelines foreign import ccall safe "dynamic" unwrapVkCreateComputePipelinesSafe :: PFN_vkCreateComputePipelines -> HS_vkCreateComputePipelines instance VulkanProc "vkCreateComputePipelines" where type VkProcType "vkCreateComputePipelines" = HS_vkCreateComputePipelines vkProcSymbol = _VkCreateComputePipelines {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateComputePipelinesUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateComputePipelinesSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroyPipeline :: CString pattern VkDestroyPipeline <- (is_VkDestroyPipeline -> True) where VkDestroyPipeline = _VkDestroyPipeline {-# INLINE _VkDestroyPipeline #-} _VkDestroyPipeline :: CString _VkDestroyPipeline = Ptr "vkDestroyPipeline\NUL"# {-# INLINE is_VkDestroyPipeline #-} is_VkDestroyPipeline :: CString -> Bool is_VkDestroyPipeline = (EQ ==) . cmpCStrings _VkDestroyPipeline type VkDestroyPipeline = "vkDestroyPipeline" -- | -- > void vkDestroyPipeline -- > ( VkDevice device -- > , VkPipeline pipeline -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyPipeline vkDestroyPipeline registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyPipeline <- vkGetDeviceProc @VkDestroyPipeline vkDevice -- -- or less efficient: -- -- > myDestroyPipeline <- vkGetProc @VkDestroyPipeline -- -- __Note:__ @vkDestroyPipelineUnsafe@ and @vkDestroyPipelineSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyPipeline@ is an alias -- of @vkDestroyPipelineUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyPipelineSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroyPipeline" vkDestroyPipelineUnsafe :: VkDevice -- ^ device -> VkPipeline -- ^ pipeline -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyPipelineUnsafe :: VkDevice -- ^ device -> VkPipeline -- ^ pipeline -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyPipelineUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroyPipeline) {-# NOINLINE vkDestroyPipelineUnsafe #-} #endif -- | -- > void vkDestroyPipeline -- > ( VkDevice device -- > , VkPipeline pipeline -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyPipeline vkDestroyPipeline registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyPipeline <- vkGetDeviceProc @VkDestroyPipeline vkDevice -- -- or less efficient: -- -- > myDestroyPipeline <- vkGetProc @VkDestroyPipeline -- -- __Note:__ @vkDestroyPipelineUnsafe@ and @vkDestroyPipelineSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyPipeline@ is an alias -- of @vkDestroyPipelineUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyPipelineSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroyPipeline" vkDestroyPipelineSafe :: VkDevice -- ^ device -> VkPipeline -- ^ pipeline -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyPipelineSafe :: VkDevice -- ^ device -> VkPipeline -- ^ pipeline -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyPipelineSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroyPipeline) {-# NOINLINE vkDestroyPipelineSafe #-} #endif -- | -- > void vkDestroyPipeline -- > ( VkDevice device -- > , VkPipeline pipeline -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyPipeline vkDestroyPipeline registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyPipeline <- vkGetDeviceProc @VkDestroyPipeline vkDevice -- -- or less efficient: -- -- > myDestroyPipeline <- vkGetProc @VkDestroyPipeline -- -- __Note:__ @vkDestroyPipelineUnsafe@ and @vkDestroyPipelineSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyPipeline@ is an alias -- of @vkDestroyPipelineUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyPipelineSafe@. -- vkDestroyPipeline :: VkDevice -- ^ device -> VkPipeline -- ^ pipeline -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroyPipeline = vkDestroyPipelineUnsafe #else vkDestroyPipeline = vkDestroyPipelineSafe #endif {-# INLINE vkDestroyPipeline #-} -- | > void vkDestroyPipeline -- > ( VkDevice device -- > , VkPipeline pipeline -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyPipeline vkDestroyPipeline registry at www.khronos.org> type HS_vkDestroyPipeline = VkDevice -- ^ device -> VkPipeline -- ^ pipeline -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroyPipeline = FunPtr HS_vkDestroyPipeline foreign import ccall unsafe "dynamic" unwrapVkDestroyPipelineUnsafe :: PFN_vkDestroyPipeline -> HS_vkDestroyPipeline foreign import ccall safe "dynamic" unwrapVkDestroyPipelineSafe :: PFN_vkDestroyPipeline -> HS_vkDestroyPipeline instance VulkanProc "vkDestroyPipeline" where type VkProcType "vkDestroyPipeline" = HS_vkDestroyPipeline vkProcSymbol = _VkDestroyPipeline {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroyPipelineUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroyPipelineSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreatePipelineLayout :: CString pattern VkCreatePipelineLayout <- (is_VkCreatePipelineLayout -> True) where VkCreatePipelineLayout = _VkCreatePipelineLayout {-# INLINE _VkCreatePipelineLayout #-} _VkCreatePipelineLayout :: CString _VkCreatePipelineLayout = Ptr "vkCreatePipelineLayout\NUL"# {-# INLINE is_VkCreatePipelineLayout #-} is_VkCreatePipelineLayout :: CString -> Bool is_VkCreatePipelineLayout = (EQ ==) . cmpCStrings _VkCreatePipelineLayout type VkCreatePipelineLayout = "vkCreatePipelineLayout" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreatePipelineLayout -- > ( VkDevice device -- > , const VkPipelineLayoutCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkPipelineLayout* pPipelineLayout -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreatePipelineLayout vkCreatePipelineLayout registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreatePipelineLayout <- vkGetDeviceProc @VkCreatePipelineLayout vkDevice -- -- or less efficient: -- -- > myCreatePipelineLayout <- vkGetProc @VkCreatePipelineLayout -- -- __Note:__ @vkCreatePipelineLayoutUnsafe@ and @vkCreatePipelineLayoutSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreatePipelineLayout@ is an alias -- of @vkCreatePipelineLayoutUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreatePipelineLayoutSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreatePipelineLayout" vkCreatePipelineLayoutUnsafe :: VkDevice -- ^ device -> Ptr VkPipelineLayoutCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipelineLayout -- ^ pPipelineLayout -> IO VkResult #else vkCreatePipelineLayoutUnsafe :: VkDevice -- ^ device -> Ptr VkPipelineLayoutCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipelineLayout -- ^ pPipelineLayout -> IO VkResult vkCreatePipelineLayoutUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreatePipelineLayout) {-# NOINLINE vkCreatePipelineLayoutUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreatePipelineLayout -- > ( VkDevice device -- > , const VkPipelineLayoutCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkPipelineLayout* pPipelineLayout -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreatePipelineLayout vkCreatePipelineLayout registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreatePipelineLayout <- vkGetDeviceProc @VkCreatePipelineLayout vkDevice -- -- or less efficient: -- -- > myCreatePipelineLayout <- vkGetProc @VkCreatePipelineLayout -- -- __Note:__ @vkCreatePipelineLayoutUnsafe@ and @vkCreatePipelineLayoutSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreatePipelineLayout@ is an alias -- of @vkCreatePipelineLayoutUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreatePipelineLayoutSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreatePipelineLayout" vkCreatePipelineLayoutSafe :: VkDevice -- ^ device -> Ptr VkPipelineLayoutCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipelineLayout -- ^ pPipelineLayout -> IO VkResult #else vkCreatePipelineLayoutSafe :: VkDevice -- ^ device -> Ptr VkPipelineLayoutCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipelineLayout -- ^ pPipelineLayout -> IO VkResult vkCreatePipelineLayoutSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreatePipelineLayout) {-# NOINLINE vkCreatePipelineLayoutSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreatePipelineLayout -- > ( VkDevice device -- > , const VkPipelineLayoutCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkPipelineLayout* pPipelineLayout -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreatePipelineLayout vkCreatePipelineLayout registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreatePipelineLayout <- vkGetDeviceProc @VkCreatePipelineLayout vkDevice -- -- or less efficient: -- -- > myCreatePipelineLayout <- vkGetProc @VkCreatePipelineLayout -- -- __Note:__ @vkCreatePipelineLayoutUnsafe@ and @vkCreatePipelineLayoutSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreatePipelineLayout@ is an alias -- of @vkCreatePipelineLayoutUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreatePipelineLayoutSafe@. -- vkCreatePipelineLayout :: VkDevice -- ^ device -> Ptr VkPipelineLayoutCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipelineLayout -- ^ pPipelineLayout -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreatePipelineLayout = vkCreatePipelineLayoutUnsafe #else vkCreatePipelineLayout = vkCreatePipelineLayoutSafe #endif {-# INLINE vkCreatePipelineLayout #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreatePipelineLayout -- > ( VkDevice device -- > , const VkPipelineLayoutCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkPipelineLayout* pPipelineLayout -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreatePipelineLayout vkCreatePipelineLayout registry at www.khronos.org> type HS_vkCreatePipelineLayout = VkDevice -- ^ device -> Ptr VkPipelineLayoutCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkPipelineLayout -- ^ pPipelineLayout -> IO VkResult type PFN_vkCreatePipelineLayout = FunPtr HS_vkCreatePipelineLayout foreign import ccall unsafe "dynamic" unwrapVkCreatePipelineLayoutUnsafe :: PFN_vkCreatePipelineLayout -> HS_vkCreatePipelineLayout foreign import ccall safe "dynamic" unwrapVkCreatePipelineLayoutSafe :: PFN_vkCreatePipelineLayout -> HS_vkCreatePipelineLayout instance VulkanProc "vkCreatePipelineLayout" where type VkProcType "vkCreatePipelineLayout" = HS_vkCreatePipelineLayout vkProcSymbol = _VkCreatePipelineLayout {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreatePipelineLayoutUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreatePipelineLayoutSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroyPipelineLayout :: CString pattern VkDestroyPipelineLayout <- (is_VkDestroyPipelineLayout -> True) where VkDestroyPipelineLayout = _VkDestroyPipelineLayout {-# INLINE _VkDestroyPipelineLayout #-} _VkDestroyPipelineLayout :: CString _VkDestroyPipelineLayout = Ptr "vkDestroyPipelineLayout\NUL"# {-# INLINE is_VkDestroyPipelineLayout #-} is_VkDestroyPipelineLayout :: CString -> Bool is_VkDestroyPipelineLayout = (EQ ==) . cmpCStrings _VkDestroyPipelineLayout type VkDestroyPipelineLayout = "vkDestroyPipelineLayout" -- | -- > void vkDestroyPipelineLayout -- > ( VkDevice device -- > , VkPipelineLayout pipelineLayout -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyPipelineLayout vkDestroyPipelineLayout registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyPipelineLayout <- vkGetDeviceProc @VkDestroyPipelineLayout vkDevice -- -- or less efficient: -- -- > myDestroyPipelineLayout <- vkGetProc @VkDestroyPipelineLayout -- -- __Note:__ @vkDestroyPipelineLayoutUnsafe@ and @vkDestroyPipelineLayoutSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyPipelineLayout@ is an alias -- of @vkDestroyPipelineLayoutUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyPipelineLayoutSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroyPipelineLayout" vkDestroyPipelineLayoutUnsafe :: VkDevice -- ^ device -> VkPipelineLayout -- ^ pipelineLayout -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyPipelineLayoutUnsafe :: VkDevice -- ^ device -> VkPipelineLayout -- ^ pipelineLayout -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyPipelineLayoutUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroyPipelineLayout) {-# NOINLINE vkDestroyPipelineLayoutUnsafe #-} #endif -- | -- > void vkDestroyPipelineLayout -- > ( VkDevice device -- > , VkPipelineLayout pipelineLayout -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyPipelineLayout vkDestroyPipelineLayout registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyPipelineLayout <- vkGetDeviceProc @VkDestroyPipelineLayout vkDevice -- -- or less efficient: -- -- > myDestroyPipelineLayout <- vkGetProc @VkDestroyPipelineLayout -- -- __Note:__ @vkDestroyPipelineLayoutUnsafe@ and @vkDestroyPipelineLayoutSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyPipelineLayout@ is an alias -- of @vkDestroyPipelineLayoutUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyPipelineLayoutSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroyPipelineLayout" vkDestroyPipelineLayoutSafe :: VkDevice -- ^ device -> VkPipelineLayout -- ^ pipelineLayout -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyPipelineLayoutSafe :: VkDevice -- ^ device -> VkPipelineLayout -- ^ pipelineLayout -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyPipelineLayoutSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroyPipelineLayout) {-# NOINLINE vkDestroyPipelineLayoutSafe #-} #endif -- | -- > void vkDestroyPipelineLayout -- > ( VkDevice device -- > , VkPipelineLayout pipelineLayout -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyPipelineLayout vkDestroyPipelineLayout registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyPipelineLayout <- vkGetDeviceProc @VkDestroyPipelineLayout vkDevice -- -- or less efficient: -- -- > myDestroyPipelineLayout <- vkGetProc @VkDestroyPipelineLayout -- -- __Note:__ @vkDestroyPipelineLayoutUnsafe@ and @vkDestroyPipelineLayoutSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyPipelineLayout@ is an alias -- of @vkDestroyPipelineLayoutUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyPipelineLayoutSafe@. -- vkDestroyPipelineLayout :: VkDevice -- ^ device -> VkPipelineLayout -- ^ pipelineLayout -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroyPipelineLayout = vkDestroyPipelineLayoutUnsafe #else vkDestroyPipelineLayout = vkDestroyPipelineLayoutSafe #endif {-# INLINE vkDestroyPipelineLayout #-} -- | > void vkDestroyPipelineLayout -- > ( VkDevice device -- > , VkPipelineLayout pipelineLayout -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyPipelineLayout vkDestroyPipelineLayout registry at www.khronos.org> type HS_vkDestroyPipelineLayout = VkDevice -- ^ device -> VkPipelineLayout -- ^ pipelineLayout -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroyPipelineLayout = FunPtr HS_vkDestroyPipelineLayout foreign import ccall unsafe "dynamic" unwrapVkDestroyPipelineLayoutUnsafe :: PFN_vkDestroyPipelineLayout -> HS_vkDestroyPipelineLayout foreign import ccall safe "dynamic" unwrapVkDestroyPipelineLayoutSafe :: PFN_vkDestroyPipelineLayout -> HS_vkDestroyPipelineLayout instance VulkanProc "vkDestroyPipelineLayout" where type VkProcType "vkDestroyPipelineLayout" = HS_vkDestroyPipelineLayout vkProcSymbol = _VkDestroyPipelineLayout {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroyPipelineLayoutUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroyPipelineLayoutSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreateSampler :: CString pattern VkCreateSampler <- (is_VkCreateSampler -> True) where VkCreateSampler = _VkCreateSampler {-# INLINE _VkCreateSampler #-} _VkCreateSampler :: CString _VkCreateSampler = Ptr "vkCreateSampler\NUL"# {-# INLINE is_VkCreateSampler #-} is_VkCreateSampler :: CString -> Bool is_VkCreateSampler = (EQ ==) . cmpCStrings _VkCreateSampler type VkCreateSampler = "vkCreateSampler" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateSampler -- > ( VkDevice device -- > , const VkSamplerCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkSampler* pSampler -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateSampler vkCreateSampler registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateSampler <- vkGetDeviceProc @VkCreateSampler vkDevice -- -- or less efficient: -- -- > myCreateSampler <- vkGetProc @VkCreateSampler -- -- __Note:__ @vkCreateSamplerUnsafe@ and @vkCreateSamplerSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateSampler@ is an alias -- of @vkCreateSamplerUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateSamplerSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateSampler" vkCreateSamplerUnsafe :: VkDevice -- ^ device -> Ptr VkSamplerCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkSampler -- ^ pSampler -> IO VkResult #else vkCreateSamplerUnsafe :: VkDevice -- ^ device -> Ptr VkSamplerCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkSampler -- ^ pSampler -> IO VkResult vkCreateSamplerUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateSampler) {-# NOINLINE vkCreateSamplerUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateSampler -- > ( VkDevice device -- > , const VkSamplerCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkSampler* pSampler -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateSampler vkCreateSampler registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateSampler <- vkGetDeviceProc @VkCreateSampler vkDevice -- -- or less efficient: -- -- > myCreateSampler <- vkGetProc @VkCreateSampler -- -- __Note:__ @vkCreateSamplerUnsafe@ and @vkCreateSamplerSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateSampler@ is an alias -- of @vkCreateSamplerUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateSamplerSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateSampler" vkCreateSamplerSafe :: VkDevice -- ^ device -> Ptr VkSamplerCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkSampler -- ^ pSampler -> IO VkResult #else vkCreateSamplerSafe :: VkDevice -- ^ device -> Ptr VkSamplerCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkSampler -- ^ pSampler -> IO VkResult vkCreateSamplerSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateSampler) {-# NOINLINE vkCreateSamplerSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateSampler -- > ( VkDevice device -- > , const VkSamplerCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkSampler* pSampler -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateSampler vkCreateSampler registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateSampler <- vkGetDeviceProc @VkCreateSampler vkDevice -- -- or less efficient: -- -- > myCreateSampler <- vkGetProc @VkCreateSampler -- -- __Note:__ @vkCreateSamplerUnsafe@ and @vkCreateSamplerSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateSampler@ is an alias -- of @vkCreateSamplerUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateSamplerSafe@. -- vkCreateSampler :: VkDevice -- ^ device -> Ptr VkSamplerCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkSampler -- ^ pSampler -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateSampler = vkCreateSamplerUnsafe #else vkCreateSampler = vkCreateSamplerSafe #endif {-# INLINE vkCreateSampler #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateSampler -- > ( VkDevice device -- > , const VkSamplerCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkSampler* pSampler -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateSampler vkCreateSampler registry at www.khronos.org> type HS_vkCreateSampler = VkDevice -- ^ device -> Ptr VkSamplerCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkSampler -- ^ pSampler -> IO VkResult type PFN_vkCreateSampler = FunPtr HS_vkCreateSampler foreign import ccall unsafe "dynamic" unwrapVkCreateSamplerUnsafe :: PFN_vkCreateSampler -> HS_vkCreateSampler foreign import ccall safe "dynamic" unwrapVkCreateSamplerSafe :: PFN_vkCreateSampler -> HS_vkCreateSampler instance VulkanProc "vkCreateSampler" where type VkProcType "vkCreateSampler" = HS_vkCreateSampler vkProcSymbol = _VkCreateSampler {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateSamplerUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateSamplerSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroySampler :: CString pattern VkDestroySampler <- (is_VkDestroySampler -> True) where VkDestroySampler = _VkDestroySampler {-# INLINE _VkDestroySampler #-} _VkDestroySampler :: CString _VkDestroySampler = Ptr "vkDestroySampler\NUL"# {-# INLINE is_VkDestroySampler #-} is_VkDestroySampler :: CString -> Bool is_VkDestroySampler = (EQ ==) . cmpCStrings _VkDestroySampler type VkDestroySampler = "vkDestroySampler" -- | -- > void vkDestroySampler -- > ( VkDevice device -- > , VkSampler sampler -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroySampler vkDestroySampler registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroySampler <- vkGetDeviceProc @VkDestroySampler vkDevice -- -- or less efficient: -- -- > myDestroySampler <- vkGetProc @VkDestroySampler -- -- __Note:__ @vkDestroySamplerUnsafe@ and @vkDestroySamplerSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroySampler@ is an alias -- of @vkDestroySamplerUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroySamplerSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroySampler" vkDestroySamplerUnsafe :: VkDevice -- ^ device -> VkSampler -- ^ sampler -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroySamplerUnsafe :: VkDevice -- ^ device -> VkSampler -- ^ sampler -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroySamplerUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroySampler) {-# NOINLINE vkDestroySamplerUnsafe #-} #endif -- | -- > void vkDestroySampler -- > ( VkDevice device -- > , VkSampler sampler -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroySampler vkDestroySampler registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroySampler <- vkGetDeviceProc @VkDestroySampler vkDevice -- -- or less efficient: -- -- > myDestroySampler <- vkGetProc @VkDestroySampler -- -- __Note:__ @vkDestroySamplerUnsafe@ and @vkDestroySamplerSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroySampler@ is an alias -- of @vkDestroySamplerUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroySamplerSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroySampler" vkDestroySamplerSafe :: VkDevice -- ^ device -> VkSampler -- ^ sampler -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroySamplerSafe :: VkDevice -- ^ device -> VkSampler -- ^ sampler -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroySamplerSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroySampler) {-# NOINLINE vkDestroySamplerSafe #-} #endif -- | -- > void vkDestroySampler -- > ( VkDevice device -- > , VkSampler sampler -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroySampler vkDestroySampler registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroySampler <- vkGetDeviceProc @VkDestroySampler vkDevice -- -- or less efficient: -- -- > myDestroySampler <- vkGetProc @VkDestroySampler -- -- __Note:__ @vkDestroySamplerUnsafe@ and @vkDestroySamplerSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroySampler@ is an alias -- of @vkDestroySamplerUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroySamplerSafe@. -- vkDestroySampler :: VkDevice -- ^ device -> VkSampler -- ^ sampler -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroySampler = vkDestroySamplerUnsafe #else vkDestroySampler = vkDestroySamplerSafe #endif {-# INLINE vkDestroySampler #-} -- | > void vkDestroySampler -- > ( VkDevice device -- > , VkSampler sampler -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroySampler vkDestroySampler registry at www.khronos.org> type HS_vkDestroySampler = VkDevice -- ^ device -> VkSampler -- ^ sampler -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroySampler = FunPtr HS_vkDestroySampler foreign import ccall unsafe "dynamic" unwrapVkDestroySamplerUnsafe :: PFN_vkDestroySampler -> HS_vkDestroySampler foreign import ccall safe "dynamic" unwrapVkDestroySamplerSafe :: PFN_vkDestroySampler -> HS_vkDestroySampler instance VulkanProc "vkDestroySampler" where type VkProcType "vkDestroySampler" = HS_vkDestroySampler vkProcSymbol = _VkDestroySampler {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroySamplerUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroySamplerSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreateDescriptorSetLayout :: CString pattern VkCreateDescriptorSetLayout <- (is_VkCreateDescriptorSetLayout -> True) where VkCreateDescriptorSetLayout = _VkCreateDescriptorSetLayout {-# INLINE _VkCreateDescriptorSetLayout #-} _VkCreateDescriptorSetLayout :: CString _VkCreateDescriptorSetLayout = Ptr "vkCreateDescriptorSetLayout\NUL"# {-# INLINE is_VkCreateDescriptorSetLayout #-} is_VkCreateDescriptorSetLayout :: CString -> Bool is_VkCreateDescriptorSetLayout = (EQ ==) . cmpCStrings _VkCreateDescriptorSetLayout type VkCreateDescriptorSetLayout = "vkCreateDescriptorSetLayout" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateDescriptorSetLayout -- > ( VkDevice device -- > , const VkDescriptorSetLayoutCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkDescriptorSetLayout* pSetLayout -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateDescriptorSetLayout <- vkGetDeviceProc @VkCreateDescriptorSetLayout vkDevice -- -- or less efficient: -- -- > myCreateDescriptorSetLayout <- vkGetProc @VkCreateDescriptorSetLayout -- -- __Note:__ @vkCreateDescriptorSetLayoutUnsafe@ and @vkCreateDescriptorSetLayoutSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateDescriptorSetLayout@ is an alias -- of @vkCreateDescriptorSetLayoutUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateDescriptorSetLayoutSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateDescriptorSetLayout" vkCreateDescriptorSetLayoutUnsafe :: VkDevice -- ^ device -> Ptr VkDescriptorSetLayoutCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDescriptorSetLayout -- ^ pSetLayout -> IO VkResult #else vkCreateDescriptorSetLayoutUnsafe :: VkDevice -- ^ device -> Ptr VkDescriptorSetLayoutCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDescriptorSetLayout -- ^ pSetLayout -> IO VkResult vkCreateDescriptorSetLayoutUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateDescriptorSetLayout) {-# NOINLINE vkCreateDescriptorSetLayoutUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateDescriptorSetLayout -- > ( VkDevice device -- > , const VkDescriptorSetLayoutCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkDescriptorSetLayout* pSetLayout -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateDescriptorSetLayout <- vkGetDeviceProc @VkCreateDescriptorSetLayout vkDevice -- -- or less efficient: -- -- > myCreateDescriptorSetLayout <- vkGetProc @VkCreateDescriptorSetLayout -- -- __Note:__ @vkCreateDescriptorSetLayoutUnsafe@ and @vkCreateDescriptorSetLayoutSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateDescriptorSetLayout@ is an alias -- of @vkCreateDescriptorSetLayoutUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateDescriptorSetLayoutSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateDescriptorSetLayout" vkCreateDescriptorSetLayoutSafe :: VkDevice -- ^ device -> Ptr VkDescriptorSetLayoutCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDescriptorSetLayout -- ^ pSetLayout -> IO VkResult #else vkCreateDescriptorSetLayoutSafe :: VkDevice -- ^ device -> Ptr VkDescriptorSetLayoutCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDescriptorSetLayout -- ^ pSetLayout -> IO VkResult vkCreateDescriptorSetLayoutSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateDescriptorSetLayout) {-# NOINLINE vkCreateDescriptorSetLayoutSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateDescriptorSetLayout -- > ( VkDevice device -- > , const VkDescriptorSetLayoutCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkDescriptorSetLayout* pSetLayout -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateDescriptorSetLayout <- vkGetDeviceProc @VkCreateDescriptorSetLayout vkDevice -- -- or less efficient: -- -- > myCreateDescriptorSetLayout <- vkGetProc @VkCreateDescriptorSetLayout -- -- __Note:__ @vkCreateDescriptorSetLayoutUnsafe@ and @vkCreateDescriptorSetLayoutSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateDescriptorSetLayout@ is an alias -- of @vkCreateDescriptorSetLayoutUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateDescriptorSetLayoutSafe@. -- vkCreateDescriptorSetLayout :: VkDevice -- ^ device -> Ptr VkDescriptorSetLayoutCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDescriptorSetLayout -- ^ pSetLayout -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateDescriptorSetLayout = vkCreateDescriptorSetLayoutUnsafe #else vkCreateDescriptorSetLayout = vkCreateDescriptorSetLayoutSafe #endif {-# INLINE vkCreateDescriptorSetLayout #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateDescriptorSetLayout -- > ( VkDevice device -- > , const VkDescriptorSetLayoutCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkDescriptorSetLayout* pSetLayout -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout registry at www.khronos.org> type HS_vkCreateDescriptorSetLayout = VkDevice -- ^ device -> Ptr VkDescriptorSetLayoutCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDescriptorSetLayout -- ^ pSetLayout -> IO VkResult type PFN_vkCreateDescriptorSetLayout = FunPtr HS_vkCreateDescriptorSetLayout foreign import ccall unsafe "dynamic" unwrapVkCreateDescriptorSetLayoutUnsafe :: PFN_vkCreateDescriptorSetLayout -> HS_vkCreateDescriptorSetLayout foreign import ccall safe "dynamic" unwrapVkCreateDescriptorSetLayoutSafe :: PFN_vkCreateDescriptorSetLayout -> HS_vkCreateDescriptorSetLayout instance VulkanProc "vkCreateDescriptorSetLayout" where type VkProcType "vkCreateDescriptorSetLayout" = HS_vkCreateDescriptorSetLayout vkProcSymbol = _VkCreateDescriptorSetLayout {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateDescriptorSetLayoutUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateDescriptorSetLayoutSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroyDescriptorSetLayout :: CString pattern VkDestroyDescriptorSetLayout <- (is_VkDestroyDescriptorSetLayout -> True) where VkDestroyDescriptorSetLayout = _VkDestroyDescriptorSetLayout {-# INLINE _VkDestroyDescriptorSetLayout #-} _VkDestroyDescriptorSetLayout :: CString _VkDestroyDescriptorSetLayout = Ptr "vkDestroyDescriptorSetLayout\NUL"# {-# INLINE is_VkDestroyDescriptorSetLayout #-} is_VkDestroyDescriptorSetLayout :: CString -> Bool is_VkDestroyDescriptorSetLayout = (EQ ==) . cmpCStrings _VkDestroyDescriptorSetLayout type VkDestroyDescriptorSetLayout = "vkDestroyDescriptorSetLayout" -- | -- > void vkDestroyDescriptorSetLayout -- > ( VkDevice device -- > , VkDescriptorSetLayout descriptorSetLayout -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyDescriptorSetLayout <- vkGetDeviceProc @VkDestroyDescriptorSetLayout vkDevice -- -- or less efficient: -- -- > myDestroyDescriptorSetLayout <- vkGetProc @VkDestroyDescriptorSetLayout -- -- __Note:__ @vkDestroyDescriptorSetLayoutUnsafe@ and @vkDestroyDescriptorSetLayoutSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyDescriptorSetLayout@ is an alias -- of @vkDestroyDescriptorSetLayoutUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyDescriptorSetLayoutSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroyDescriptorSetLayout" vkDestroyDescriptorSetLayoutUnsafe :: VkDevice -- ^ device -> VkDescriptorSetLayout -- ^ descriptorSetLayout -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyDescriptorSetLayoutUnsafe :: VkDevice -- ^ device -> VkDescriptorSetLayout -- ^ descriptorSetLayout -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyDescriptorSetLayoutUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroyDescriptorSetLayout) {-# NOINLINE vkDestroyDescriptorSetLayoutUnsafe #-} #endif -- | -- > void vkDestroyDescriptorSetLayout -- > ( VkDevice device -- > , VkDescriptorSetLayout descriptorSetLayout -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyDescriptorSetLayout <- vkGetDeviceProc @VkDestroyDescriptorSetLayout vkDevice -- -- or less efficient: -- -- > myDestroyDescriptorSetLayout <- vkGetProc @VkDestroyDescriptorSetLayout -- -- __Note:__ @vkDestroyDescriptorSetLayoutUnsafe@ and @vkDestroyDescriptorSetLayoutSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyDescriptorSetLayout@ is an alias -- of @vkDestroyDescriptorSetLayoutUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyDescriptorSetLayoutSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroyDescriptorSetLayout" vkDestroyDescriptorSetLayoutSafe :: VkDevice -- ^ device -> VkDescriptorSetLayout -- ^ descriptorSetLayout -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyDescriptorSetLayoutSafe :: VkDevice -- ^ device -> VkDescriptorSetLayout -- ^ descriptorSetLayout -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyDescriptorSetLayoutSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroyDescriptorSetLayout) {-# NOINLINE vkDestroyDescriptorSetLayoutSafe #-} #endif -- | -- > void vkDestroyDescriptorSetLayout -- > ( VkDevice device -- > , VkDescriptorSetLayout descriptorSetLayout -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyDescriptorSetLayout <- vkGetDeviceProc @VkDestroyDescriptorSetLayout vkDevice -- -- or less efficient: -- -- > myDestroyDescriptorSetLayout <- vkGetProc @VkDestroyDescriptorSetLayout -- -- __Note:__ @vkDestroyDescriptorSetLayoutUnsafe@ and @vkDestroyDescriptorSetLayoutSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyDescriptorSetLayout@ is an alias -- of @vkDestroyDescriptorSetLayoutUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyDescriptorSetLayoutSafe@. -- vkDestroyDescriptorSetLayout :: VkDevice -- ^ device -> VkDescriptorSetLayout -- ^ descriptorSetLayout -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroyDescriptorSetLayout = vkDestroyDescriptorSetLayoutUnsafe #else vkDestroyDescriptorSetLayout = vkDestroyDescriptorSetLayoutSafe #endif {-# INLINE vkDestroyDescriptorSetLayout #-} -- | > void vkDestroyDescriptorSetLayout -- > ( VkDevice device -- > , VkDescriptorSetLayout descriptorSetLayout -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout registry at www.khronos.org> type HS_vkDestroyDescriptorSetLayout = VkDevice -- ^ device -> VkDescriptorSetLayout -- ^ descriptorSetLayout -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroyDescriptorSetLayout = FunPtr HS_vkDestroyDescriptorSetLayout foreign import ccall unsafe "dynamic" unwrapVkDestroyDescriptorSetLayoutUnsafe :: PFN_vkDestroyDescriptorSetLayout -> HS_vkDestroyDescriptorSetLayout foreign import ccall safe "dynamic" unwrapVkDestroyDescriptorSetLayoutSafe :: PFN_vkDestroyDescriptorSetLayout -> HS_vkDestroyDescriptorSetLayout instance VulkanProc "vkDestroyDescriptorSetLayout" where type VkProcType "vkDestroyDescriptorSetLayout" = HS_vkDestroyDescriptorSetLayout vkProcSymbol = _VkDestroyDescriptorSetLayout {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroyDescriptorSetLayoutUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroyDescriptorSetLayoutSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreateDescriptorPool :: CString pattern VkCreateDescriptorPool <- (is_VkCreateDescriptorPool -> True) where VkCreateDescriptorPool = _VkCreateDescriptorPool {-# INLINE _VkCreateDescriptorPool #-} _VkCreateDescriptorPool :: CString _VkCreateDescriptorPool = Ptr "vkCreateDescriptorPool\NUL"# {-# INLINE is_VkCreateDescriptorPool #-} is_VkCreateDescriptorPool :: CString -> Bool is_VkCreateDescriptorPool = (EQ ==) . cmpCStrings _VkCreateDescriptorPool type VkCreateDescriptorPool = "vkCreateDescriptorPool" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_FRAGMENTATION_EXT'. -- -- > VkResult vkCreateDescriptorPool -- > ( VkDevice device -- > , const VkDescriptorPoolCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkDescriptorPool* pDescriptorPool -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateDescriptorPool vkCreateDescriptorPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateDescriptorPool <- vkGetDeviceProc @VkCreateDescriptorPool vkDevice -- -- or less efficient: -- -- > myCreateDescriptorPool <- vkGetProc @VkCreateDescriptorPool -- -- __Note:__ @vkCreateDescriptorPoolUnsafe@ and @vkCreateDescriptorPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateDescriptorPool@ is an alias -- of @vkCreateDescriptorPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateDescriptorPoolSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateDescriptorPool" vkCreateDescriptorPoolUnsafe :: VkDevice -- ^ device -> Ptr VkDescriptorPoolCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDescriptorPool -- ^ pDescriptorPool -> IO VkResult #else vkCreateDescriptorPoolUnsafe :: VkDevice -- ^ device -> Ptr VkDescriptorPoolCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDescriptorPool -- ^ pDescriptorPool -> IO VkResult vkCreateDescriptorPoolUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateDescriptorPool) {-# NOINLINE vkCreateDescriptorPoolUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_FRAGMENTATION_EXT'. -- -- > VkResult vkCreateDescriptorPool -- > ( VkDevice device -- > , const VkDescriptorPoolCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkDescriptorPool* pDescriptorPool -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateDescriptorPool vkCreateDescriptorPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateDescriptorPool <- vkGetDeviceProc @VkCreateDescriptorPool vkDevice -- -- or less efficient: -- -- > myCreateDescriptorPool <- vkGetProc @VkCreateDescriptorPool -- -- __Note:__ @vkCreateDescriptorPoolUnsafe@ and @vkCreateDescriptorPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateDescriptorPool@ is an alias -- of @vkCreateDescriptorPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateDescriptorPoolSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateDescriptorPool" vkCreateDescriptorPoolSafe :: VkDevice -- ^ device -> Ptr VkDescriptorPoolCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDescriptorPool -- ^ pDescriptorPool -> IO VkResult #else vkCreateDescriptorPoolSafe :: VkDevice -- ^ device -> Ptr VkDescriptorPoolCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDescriptorPool -- ^ pDescriptorPool -> IO VkResult vkCreateDescriptorPoolSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateDescriptorPool) {-# NOINLINE vkCreateDescriptorPoolSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_FRAGMENTATION_EXT'. -- -- > VkResult vkCreateDescriptorPool -- > ( VkDevice device -- > , const VkDescriptorPoolCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkDescriptorPool* pDescriptorPool -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateDescriptorPool vkCreateDescriptorPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateDescriptorPool <- vkGetDeviceProc @VkCreateDescriptorPool vkDevice -- -- or less efficient: -- -- > myCreateDescriptorPool <- vkGetProc @VkCreateDescriptorPool -- -- __Note:__ @vkCreateDescriptorPoolUnsafe@ and @vkCreateDescriptorPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateDescriptorPool@ is an alias -- of @vkCreateDescriptorPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateDescriptorPoolSafe@. -- vkCreateDescriptorPool :: VkDevice -- ^ device -> Ptr VkDescriptorPoolCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDescriptorPool -- ^ pDescriptorPool -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateDescriptorPool = vkCreateDescriptorPoolUnsafe #else vkCreateDescriptorPool = vkCreateDescriptorPoolSafe #endif {-# INLINE vkCreateDescriptorPool #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_FRAGMENTATION_EXT'. -- -- > VkResult vkCreateDescriptorPool -- > ( VkDevice device -- > , const VkDescriptorPoolCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkDescriptorPool* pDescriptorPool -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateDescriptorPool vkCreateDescriptorPool registry at www.khronos.org> type HS_vkCreateDescriptorPool = VkDevice -- ^ device -> Ptr VkDescriptorPoolCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkDescriptorPool -- ^ pDescriptorPool -> IO VkResult type PFN_vkCreateDescriptorPool = FunPtr HS_vkCreateDescriptorPool foreign import ccall unsafe "dynamic" unwrapVkCreateDescriptorPoolUnsafe :: PFN_vkCreateDescriptorPool -> HS_vkCreateDescriptorPool foreign import ccall safe "dynamic" unwrapVkCreateDescriptorPoolSafe :: PFN_vkCreateDescriptorPool -> HS_vkCreateDescriptorPool instance VulkanProc "vkCreateDescriptorPool" where type VkProcType "vkCreateDescriptorPool" = HS_vkCreateDescriptorPool vkProcSymbol = _VkCreateDescriptorPool {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateDescriptorPoolUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateDescriptorPoolSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroyDescriptorPool :: CString pattern VkDestroyDescriptorPool <- (is_VkDestroyDescriptorPool -> True) where VkDestroyDescriptorPool = _VkDestroyDescriptorPool {-# INLINE _VkDestroyDescriptorPool #-} _VkDestroyDescriptorPool :: CString _VkDestroyDescriptorPool = Ptr "vkDestroyDescriptorPool\NUL"# {-# INLINE is_VkDestroyDescriptorPool #-} is_VkDestroyDescriptorPool :: CString -> Bool is_VkDestroyDescriptorPool = (EQ ==) . cmpCStrings _VkDestroyDescriptorPool type VkDestroyDescriptorPool = "vkDestroyDescriptorPool" -- | -- > void vkDestroyDescriptorPool -- > ( VkDevice device -- > , VkDescriptorPool descriptorPool -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyDescriptorPool vkDestroyDescriptorPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyDescriptorPool <- vkGetDeviceProc @VkDestroyDescriptorPool vkDevice -- -- or less efficient: -- -- > myDestroyDescriptorPool <- vkGetProc @VkDestroyDescriptorPool -- -- __Note:__ @vkDestroyDescriptorPoolUnsafe@ and @vkDestroyDescriptorPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyDescriptorPool@ is an alias -- of @vkDestroyDescriptorPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyDescriptorPoolSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroyDescriptorPool" vkDestroyDescriptorPoolUnsafe :: VkDevice -- ^ device -> VkDescriptorPool -- ^ descriptorPool -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyDescriptorPoolUnsafe :: VkDevice -- ^ device -> VkDescriptorPool -- ^ descriptorPool -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyDescriptorPoolUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroyDescriptorPool) {-# NOINLINE vkDestroyDescriptorPoolUnsafe #-} #endif -- | -- > void vkDestroyDescriptorPool -- > ( VkDevice device -- > , VkDescriptorPool descriptorPool -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyDescriptorPool vkDestroyDescriptorPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyDescriptorPool <- vkGetDeviceProc @VkDestroyDescriptorPool vkDevice -- -- or less efficient: -- -- > myDestroyDescriptorPool <- vkGetProc @VkDestroyDescriptorPool -- -- __Note:__ @vkDestroyDescriptorPoolUnsafe@ and @vkDestroyDescriptorPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyDescriptorPool@ is an alias -- of @vkDestroyDescriptorPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyDescriptorPoolSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroyDescriptorPool" vkDestroyDescriptorPoolSafe :: VkDevice -- ^ device -> VkDescriptorPool -- ^ descriptorPool -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyDescriptorPoolSafe :: VkDevice -- ^ device -> VkDescriptorPool -- ^ descriptorPool -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyDescriptorPoolSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroyDescriptorPool) {-# NOINLINE vkDestroyDescriptorPoolSafe #-} #endif -- | -- > void vkDestroyDescriptorPool -- > ( VkDevice device -- > , VkDescriptorPool descriptorPool -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyDescriptorPool vkDestroyDescriptorPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyDescriptorPool <- vkGetDeviceProc @VkDestroyDescriptorPool vkDevice -- -- or less efficient: -- -- > myDestroyDescriptorPool <- vkGetProc @VkDestroyDescriptorPool -- -- __Note:__ @vkDestroyDescriptorPoolUnsafe@ and @vkDestroyDescriptorPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyDescriptorPool@ is an alias -- of @vkDestroyDescriptorPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyDescriptorPoolSafe@. -- vkDestroyDescriptorPool :: VkDevice -- ^ device -> VkDescriptorPool -- ^ descriptorPool -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroyDescriptorPool = vkDestroyDescriptorPoolUnsafe #else vkDestroyDescriptorPool = vkDestroyDescriptorPoolSafe #endif {-# INLINE vkDestroyDescriptorPool #-} -- | > void vkDestroyDescriptorPool -- > ( VkDevice device -- > , VkDescriptorPool descriptorPool -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyDescriptorPool vkDestroyDescriptorPool registry at www.khronos.org> type HS_vkDestroyDescriptorPool = VkDevice -- ^ device -> VkDescriptorPool -- ^ descriptorPool -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroyDescriptorPool = FunPtr HS_vkDestroyDescriptorPool foreign import ccall unsafe "dynamic" unwrapVkDestroyDescriptorPoolUnsafe :: PFN_vkDestroyDescriptorPool -> HS_vkDestroyDescriptorPool foreign import ccall safe "dynamic" unwrapVkDestroyDescriptorPoolSafe :: PFN_vkDestroyDescriptorPool -> HS_vkDestroyDescriptorPool instance VulkanProc "vkDestroyDescriptorPool" where type VkProcType "vkDestroyDescriptorPool" = HS_vkDestroyDescriptorPool vkProcSymbol = _VkDestroyDescriptorPool {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroyDescriptorPoolUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroyDescriptorPoolSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkResetDescriptorPool :: CString pattern VkResetDescriptorPool <- (is_VkResetDescriptorPool -> True) where VkResetDescriptorPool = _VkResetDescriptorPool {-# INLINE _VkResetDescriptorPool #-} _VkResetDescriptorPool :: CString _VkResetDescriptorPool = Ptr "vkResetDescriptorPool\NUL"# {-# INLINE is_VkResetDescriptorPool #-} is_VkResetDescriptorPool :: CString -> Bool is_VkResetDescriptorPool = (EQ ==) . cmpCStrings _VkResetDescriptorPool type VkResetDescriptorPool = "vkResetDescriptorPool" -- | -- Success codes: 'VK_SUCCESS'. -- -- > VkResult vkResetDescriptorPool -- > ( VkDevice device -- > , VkDescriptorPool descriptorPool -- > , VkDescriptorPoolResetFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetDescriptorPool vkResetDescriptorPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myResetDescriptorPool <- vkGetDeviceProc @VkResetDescriptorPool vkDevice -- -- or less efficient: -- -- > myResetDescriptorPool <- vkGetProc @VkResetDescriptorPool -- -- __Note:__ @vkResetDescriptorPoolUnsafe@ and @vkResetDescriptorPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkResetDescriptorPool@ is an alias -- of @vkResetDescriptorPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkResetDescriptorPoolSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkResetDescriptorPool" vkResetDescriptorPoolUnsafe :: VkDevice -- ^ device -> VkDescriptorPool -- ^ descriptorPool -> VkDescriptorPoolResetFlags -- ^ flags -> IO VkResult #else vkResetDescriptorPoolUnsafe :: VkDevice -- ^ device -> VkDescriptorPool -- ^ descriptorPool -> VkDescriptorPoolResetFlags -- ^ flags -> IO VkResult vkResetDescriptorPoolUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkResetDescriptorPool) {-# NOINLINE vkResetDescriptorPoolUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- > VkResult vkResetDescriptorPool -- > ( VkDevice device -- > , VkDescriptorPool descriptorPool -- > , VkDescriptorPoolResetFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetDescriptorPool vkResetDescriptorPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myResetDescriptorPool <- vkGetDeviceProc @VkResetDescriptorPool vkDevice -- -- or less efficient: -- -- > myResetDescriptorPool <- vkGetProc @VkResetDescriptorPool -- -- __Note:__ @vkResetDescriptorPoolUnsafe@ and @vkResetDescriptorPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkResetDescriptorPool@ is an alias -- of @vkResetDescriptorPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkResetDescriptorPoolSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkResetDescriptorPool" vkResetDescriptorPoolSafe :: VkDevice -- ^ device -> VkDescriptorPool -- ^ descriptorPool -> VkDescriptorPoolResetFlags -- ^ flags -> IO VkResult #else vkResetDescriptorPoolSafe :: VkDevice -- ^ device -> VkDescriptorPool -- ^ descriptorPool -> VkDescriptorPoolResetFlags -- ^ flags -> IO VkResult vkResetDescriptorPoolSafe = unsafeDupablePerformIO (vkGetProcSafe @VkResetDescriptorPool) {-# NOINLINE vkResetDescriptorPoolSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- > VkResult vkResetDescriptorPool -- > ( VkDevice device -- > , VkDescriptorPool descriptorPool -- > , VkDescriptorPoolResetFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetDescriptorPool vkResetDescriptorPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myResetDescriptorPool <- vkGetDeviceProc @VkResetDescriptorPool vkDevice -- -- or less efficient: -- -- > myResetDescriptorPool <- vkGetProc @VkResetDescriptorPool -- -- __Note:__ @vkResetDescriptorPoolUnsafe@ and @vkResetDescriptorPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkResetDescriptorPool@ is an alias -- of @vkResetDescriptorPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkResetDescriptorPoolSafe@. -- vkResetDescriptorPool :: VkDevice -- ^ device -> VkDescriptorPool -- ^ descriptorPool -> VkDescriptorPoolResetFlags -- ^ flags -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkResetDescriptorPool = vkResetDescriptorPoolUnsafe #else vkResetDescriptorPool = vkResetDescriptorPoolSafe #endif {-# INLINE vkResetDescriptorPool #-} -- | Success codes: 'VK_SUCCESS'. -- -- > VkResult vkResetDescriptorPool -- > ( VkDevice device -- > , VkDescriptorPool descriptorPool -- > , VkDescriptorPoolResetFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetDescriptorPool vkResetDescriptorPool registry at www.khronos.org> type HS_vkResetDescriptorPool = VkDevice -- ^ device -> VkDescriptorPool -- ^ descriptorPool -> VkDescriptorPoolResetFlags -- ^ flags -> IO VkResult type PFN_vkResetDescriptorPool = FunPtr HS_vkResetDescriptorPool foreign import ccall unsafe "dynamic" unwrapVkResetDescriptorPoolUnsafe :: PFN_vkResetDescriptorPool -> HS_vkResetDescriptorPool foreign import ccall safe "dynamic" unwrapVkResetDescriptorPoolSafe :: PFN_vkResetDescriptorPool -> HS_vkResetDescriptorPool instance VulkanProc "vkResetDescriptorPool" where type VkProcType "vkResetDescriptorPool" = HS_vkResetDescriptorPool vkProcSymbol = _VkResetDescriptorPool {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkResetDescriptorPoolUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkResetDescriptorPoolSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkAllocateDescriptorSets :: CString pattern VkAllocateDescriptorSets <- (is_VkAllocateDescriptorSets -> True) where VkAllocateDescriptorSets = _VkAllocateDescriptorSets {-# INLINE _VkAllocateDescriptorSets #-} _VkAllocateDescriptorSets :: CString _VkAllocateDescriptorSets = Ptr "vkAllocateDescriptorSets\NUL"# {-# INLINE is_VkAllocateDescriptorSets #-} is_VkAllocateDescriptorSets :: CString -> Bool is_VkAllocateDescriptorSets = (EQ ==) . cmpCStrings _VkAllocateDescriptorSets type VkAllocateDescriptorSets = "vkAllocateDescriptorSets" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_FRAGMENTED_POOL', 'VK_ERROR_OUT_OF_POOL_MEMORY'. -- -- > VkResult vkAllocateDescriptorSets -- > ( VkDevice device -- > , const VkDescriptorSetAllocateInfo* pAllocateInfo -- > , VkDescriptorSet* pDescriptorSets -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkAllocateDescriptorSets vkAllocateDescriptorSets registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myAllocateDescriptorSets <- vkGetDeviceProc @VkAllocateDescriptorSets vkDevice -- -- or less efficient: -- -- > myAllocateDescriptorSets <- vkGetProc @VkAllocateDescriptorSets -- -- __Note:__ @vkAllocateDescriptorSetsUnsafe@ and @vkAllocateDescriptorSetsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkAllocateDescriptorSets@ is an alias -- of @vkAllocateDescriptorSetsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkAllocateDescriptorSetsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkAllocateDescriptorSets" vkAllocateDescriptorSetsUnsafe :: VkDevice -- ^ device -> Ptr VkDescriptorSetAllocateInfo -- ^ pAllocateInfo -> Ptr VkDescriptorSet -- ^ pDescriptorSets -> IO VkResult #else vkAllocateDescriptorSetsUnsafe :: VkDevice -- ^ device -> Ptr VkDescriptorSetAllocateInfo -- ^ pAllocateInfo -> Ptr VkDescriptorSet -- ^ pDescriptorSets -> IO VkResult vkAllocateDescriptorSetsUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkAllocateDescriptorSets) {-# NOINLINE vkAllocateDescriptorSetsUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_FRAGMENTED_POOL', 'VK_ERROR_OUT_OF_POOL_MEMORY'. -- -- > VkResult vkAllocateDescriptorSets -- > ( VkDevice device -- > , const VkDescriptorSetAllocateInfo* pAllocateInfo -- > , VkDescriptorSet* pDescriptorSets -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkAllocateDescriptorSets vkAllocateDescriptorSets registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myAllocateDescriptorSets <- vkGetDeviceProc @VkAllocateDescriptorSets vkDevice -- -- or less efficient: -- -- > myAllocateDescriptorSets <- vkGetProc @VkAllocateDescriptorSets -- -- __Note:__ @vkAllocateDescriptorSetsUnsafe@ and @vkAllocateDescriptorSetsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkAllocateDescriptorSets@ is an alias -- of @vkAllocateDescriptorSetsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkAllocateDescriptorSetsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkAllocateDescriptorSets" vkAllocateDescriptorSetsSafe :: VkDevice -- ^ device -> Ptr VkDescriptorSetAllocateInfo -- ^ pAllocateInfo -> Ptr VkDescriptorSet -- ^ pDescriptorSets -> IO VkResult #else vkAllocateDescriptorSetsSafe :: VkDevice -- ^ device -> Ptr VkDescriptorSetAllocateInfo -- ^ pAllocateInfo -> Ptr VkDescriptorSet -- ^ pDescriptorSets -> IO VkResult vkAllocateDescriptorSetsSafe = unsafeDupablePerformIO (vkGetProcSafe @VkAllocateDescriptorSets) {-# NOINLINE vkAllocateDescriptorSetsSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_FRAGMENTED_POOL', 'VK_ERROR_OUT_OF_POOL_MEMORY'. -- -- > VkResult vkAllocateDescriptorSets -- > ( VkDevice device -- > , const VkDescriptorSetAllocateInfo* pAllocateInfo -- > , VkDescriptorSet* pDescriptorSets -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkAllocateDescriptorSets vkAllocateDescriptorSets registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myAllocateDescriptorSets <- vkGetDeviceProc @VkAllocateDescriptorSets vkDevice -- -- or less efficient: -- -- > myAllocateDescriptorSets <- vkGetProc @VkAllocateDescriptorSets -- -- __Note:__ @vkAllocateDescriptorSetsUnsafe@ and @vkAllocateDescriptorSetsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkAllocateDescriptorSets@ is an alias -- of @vkAllocateDescriptorSetsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkAllocateDescriptorSetsSafe@. -- vkAllocateDescriptorSets :: VkDevice -- ^ device -> Ptr VkDescriptorSetAllocateInfo -- ^ pAllocateInfo -> Ptr VkDescriptorSet -- ^ pDescriptorSets -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkAllocateDescriptorSets = vkAllocateDescriptorSetsUnsafe #else vkAllocateDescriptorSets = vkAllocateDescriptorSetsSafe #endif {-# INLINE vkAllocateDescriptorSets #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_FRAGMENTED_POOL', 'VK_ERROR_OUT_OF_POOL_MEMORY'. -- -- > VkResult vkAllocateDescriptorSets -- > ( VkDevice device -- > , const VkDescriptorSetAllocateInfo* pAllocateInfo -- > , VkDescriptorSet* pDescriptorSets -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkAllocateDescriptorSets vkAllocateDescriptorSets registry at www.khronos.org> type HS_vkAllocateDescriptorSets = VkDevice -- ^ device -> Ptr VkDescriptorSetAllocateInfo -- ^ pAllocateInfo -> Ptr VkDescriptorSet -- ^ pDescriptorSets -> IO VkResult type PFN_vkAllocateDescriptorSets = FunPtr HS_vkAllocateDescriptorSets foreign import ccall unsafe "dynamic" unwrapVkAllocateDescriptorSetsUnsafe :: PFN_vkAllocateDescriptorSets -> HS_vkAllocateDescriptorSets foreign import ccall safe "dynamic" unwrapVkAllocateDescriptorSetsSafe :: PFN_vkAllocateDescriptorSets -> HS_vkAllocateDescriptorSets instance VulkanProc "vkAllocateDescriptorSets" where type VkProcType "vkAllocateDescriptorSets" = HS_vkAllocateDescriptorSets vkProcSymbol = _VkAllocateDescriptorSets {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkAllocateDescriptorSetsUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkAllocateDescriptorSetsSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkFreeDescriptorSets :: CString pattern VkFreeDescriptorSets <- (is_VkFreeDescriptorSets -> True) where VkFreeDescriptorSets = _VkFreeDescriptorSets {-# INLINE _VkFreeDescriptorSets #-} _VkFreeDescriptorSets :: CString _VkFreeDescriptorSets = Ptr "vkFreeDescriptorSets\NUL"# {-# INLINE is_VkFreeDescriptorSets #-} is_VkFreeDescriptorSets :: CString -> Bool is_VkFreeDescriptorSets = (EQ ==) . cmpCStrings _VkFreeDescriptorSets type VkFreeDescriptorSets = "vkFreeDescriptorSets" -- | -- Success codes: 'VK_SUCCESS'. -- -- > VkResult vkFreeDescriptorSets -- > ( VkDevice device -- > , VkDescriptorPool descriptorPool -- > , uint32_t descriptorSetCount -- > , const VkDescriptorSet* pDescriptorSets -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkFreeDescriptorSets vkFreeDescriptorSets registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myFreeDescriptorSets <- vkGetDeviceProc @VkFreeDescriptorSets vkDevice -- -- or less efficient: -- -- > myFreeDescriptorSets <- vkGetProc @VkFreeDescriptorSets -- -- __Note:__ @vkFreeDescriptorSetsUnsafe@ and @vkFreeDescriptorSetsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkFreeDescriptorSets@ is an alias -- of @vkFreeDescriptorSetsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkFreeDescriptorSetsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkFreeDescriptorSets" vkFreeDescriptorSetsUnsafe :: VkDevice -- ^ device -> VkDescriptorPool -- ^ descriptorPool -> Word32 -- ^ descriptorSetCount -> Ptr VkDescriptorSet -- ^ pDescriptorSets -> IO VkResult #else vkFreeDescriptorSetsUnsafe :: VkDevice -- ^ device -> VkDescriptorPool -- ^ descriptorPool -> Word32 -- ^ descriptorSetCount -> Ptr VkDescriptorSet -- ^ pDescriptorSets -> IO VkResult vkFreeDescriptorSetsUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkFreeDescriptorSets) {-# NOINLINE vkFreeDescriptorSetsUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- > VkResult vkFreeDescriptorSets -- > ( VkDevice device -- > , VkDescriptorPool descriptorPool -- > , uint32_t descriptorSetCount -- > , const VkDescriptorSet* pDescriptorSets -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkFreeDescriptorSets vkFreeDescriptorSets registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myFreeDescriptorSets <- vkGetDeviceProc @VkFreeDescriptorSets vkDevice -- -- or less efficient: -- -- > myFreeDescriptorSets <- vkGetProc @VkFreeDescriptorSets -- -- __Note:__ @vkFreeDescriptorSetsUnsafe@ and @vkFreeDescriptorSetsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkFreeDescriptorSets@ is an alias -- of @vkFreeDescriptorSetsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkFreeDescriptorSetsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkFreeDescriptorSets" vkFreeDescriptorSetsSafe :: VkDevice -- ^ device -> VkDescriptorPool -- ^ descriptorPool -> Word32 -- ^ descriptorSetCount -> Ptr VkDescriptorSet -- ^ pDescriptorSets -> IO VkResult #else vkFreeDescriptorSetsSafe :: VkDevice -- ^ device -> VkDescriptorPool -- ^ descriptorPool -> Word32 -- ^ descriptorSetCount -> Ptr VkDescriptorSet -- ^ pDescriptorSets -> IO VkResult vkFreeDescriptorSetsSafe = unsafeDupablePerformIO (vkGetProcSafe @VkFreeDescriptorSets) {-# NOINLINE vkFreeDescriptorSetsSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- > VkResult vkFreeDescriptorSets -- > ( VkDevice device -- > , VkDescriptorPool descriptorPool -- > , uint32_t descriptorSetCount -- > , const VkDescriptorSet* pDescriptorSets -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkFreeDescriptorSets vkFreeDescriptorSets registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myFreeDescriptorSets <- vkGetDeviceProc @VkFreeDescriptorSets vkDevice -- -- or less efficient: -- -- > myFreeDescriptorSets <- vkGetProc @VkFreeDescriptorSets -- -- __Note:__ @vkFreeDescriptorSetsUnsafe@ and @vkFreeDescriptorSetsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkFreeDescriptorSets@ is an alias -- of @vkFreeDescriptorSetsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkFreeDescriptorSetsSafe@. -- vkFreeDescriptorSets :: VkDevice -- ^ device -> VkDescriptorPool -- ^ descriptorPool -> Word32 -- ^ descriptorSetCount -> Ptr VkDescriptorSet -- ^ pDescriptorSets -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkFreeDescriptorSets = vkFreeDescriptorSetsUnsafe #else vkFreeDescriptorSets = vkFreeDescriptorSetsSafe #endif {-# INLINE vkFreeDescriptorSets #-} -- | Success codes: 'VK_SUCCESS'. -- -- > VkResult vkFreeDescriptorSets -- > ( VkDevice device -- > , VkDescriptorPool descriptorPool -- > , uint32_t descriptorSetCount -- > , const VkDescriptorSet* pDescriptorSets -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkFreeDescriptorSets vkFreeDescriptorSets registry at www.khronos.org> type HS_vkFreeDescriptorSets = VkDevice -- ^ device -> VkDescriptorPool -- ^ descriptorPool -> Word32 -- ^ descriptorSetCount -> Ptr VkDescriptorSet -- ^ pDescriptorSets -> IO VkResult type PFN_vkFreeDescriptorSets = FunPtr HS_vkFreeDescriptorSets foreign import ccall unsafe "dynamic" unwrapVkFreeDescriptorSetsUnsafe :: PFN_vkFreeDescriptorSets -> HS_vkFreeDescriptorSets foreign import ccall safe "dynamic" unwrapVkFreeDescriptorSetsSafe :: PFN_vkFreeDescriptorSets -> HS_vkFreeDescriptorSets instance VulkanProc "vkFreeDescriptorSets" where type VkProcType "vkFreeDescriptorSets" = HS_vkFreeDescriptorSets vkProcSymbol = _VkFreeDescriptorSets {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkFreeDescriptorSetsUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkFreeDescriptorSetsSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkUpdateDescriptorSets :: CString pattern VkUpdateDescriptorSets <- (is_VkUpdateDescriptorSets -> True) where VkUpdateDescriptorSets = _VkUpdateDescriptorSets {-# INLINE _VkUpdateDescriptorSets #-} _VkUpdateDescriptorSets :: CString _VkUpdateDescriptorSets = Ptr "vkUpdateDescriptorSets\NUL"# {-# INLINE is_VkUpdateDescriptorSets #-} is_VkUpdateDescriptorSets :: CString -> Bool is_VkUpdateDescriptorSets = (EQ ==) . cmpCStrings _VkUpdateDescriptorSets type VkUpdateDescriptorSets = "vkUpdateDescriptorSets" -- | -- > void vkUpdateDescriptorSets -- > ( VkDevice device -- > , uint32_t descriptorWriteCount -- > , const VkWriteDescriptorSet* pDescriptorWrites -- > , uint32_t descriptorCopyCount -- > , const VkCopyDescriptorSet* pDescriptorCopies -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkUpdateDescriptorSets vkUpdateDescriptorSets registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myUpdateDescriptorSets <- vkGetDeviceProc @VkUpdateDescriptorSets vkDevice -- -- or less efficient: -- -- > myUpdateDescriptorSets <- vkGetProc @VkUpdateDescriptorSets -- -- __Note:__ @vkUpdateDescriptorSetsUnsafe@ and @vkUpdateDescriptorSetsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkUpdateDescriptorSets@ is an alias -- of @vkUpdateDescriptorSetsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkUpdateDescriptorSetsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkUpdateDescriptorSets" vkUpdateDescriptorSetsUnsafe :: VkDevice -- ^ device -> Word32 -- ^ descriptorWriteCount -> Ptr VkWriteDescriptorSet -- ^ pDescriptorWrites -> Word32 -- ^ descriptorCopyCount -> Ptr VkCopyDescriptorSet -- ^ pDescriptorCopies -> IO () #else vkUpdateDescriptorSetsUnsafe :: VkDevice -- ^ device -> Word32 -- ^ descriptorWriteCount -> Ptr VkWriteDescriptorSet -- ^ pDescriptorWrites -> Word32 -- ^ descriptorCopyCount -> Ptr VkCopyDescriptorSet -- ^ pDescriptorCopies -> IO () vkUpdateDescriptorSetsUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkUpdateDescriptorSets) {-# NOINLINE vkUpdateDescriptorSetsUnsafe #-} #endif -- | -- > void vkUpdateDescriptorSets -- > ( VkDevice device -- > , uint32_t descriptorWriteCount -- > , const VkWriteDescriptorSet* pDescriptorWrites -- > , uint32_t descriptorCopyCount -- > , const VkCopyDescriptorSet* pDescriptorCopies -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkUpdateDescriptorSets vkUpdateDescriptorSets registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myUpdateDescriptorSets <- vkGetDeviceProc @VkUpdateDescriptorSets vkDevice -- -- or less efficient: -- -- > myUpdateDescriptorSets <- vkGetProc @VkUpdateDescriptorSets -- -- __Note:__ @vkUpdateDescriptorSetsUnsafe@ and @vkUpdateDescriptorSetsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkUpdateDescriptorSets@ is an alias -- of @vkUpdateDescriptorSetsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkUpdateDescriptorSetsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkUpdateDescriptorSets" vkUpdateDescriptorSetsSafe :: VkDevice -- ^ device -> Word32 -- ^ descriptorWriteCount -> Ptr VkWriteDescriptorSet -- ^ pDescriptorWrites -> Word32 -- ^ descriptorCopyCount -> Ptr VkCopyDescriptorSet -- ^ pDescriptorCopies -> IO () #else vkUpdateDescriptorSetsSafe :: VkDevice -- ^ device -> Word32 -- ^ descriptorWriteCount -> Ptr VkWriteDescriptorSet -- ^ pDescriptorWrites -> Word32 -- ^ descriptorCopyCount -> Ptr VkCopyDescriptorSet -- ^ pDescriptorCopies -> IO () vkUpdateDescriptorSetsSafe = unsafeDupablePerformIO (vkGetProcSafe @VkUpdateDescriptorSets) {-# NOINLINE vkUpdateDescriptorSetsSafe #-} #endif -- | -- > void vkUpdateDescriptorSets -- > ( VkDevice device -- > , uint32_t descriptorWriteCount -- > , const VkWriteDescriptorSet* pDescriptorWrites -- > , uint32_t descriptorCopyCount -- > , const VkCopyDescriptorSet* pDescriptorCopies -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkUpdateDescriptorSets vkUpdateDescriptorSets registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myUpdateDescriptorSets <- vkGetDeviceProc @VkUpdateDescriptorSets vkDevice -- -- or less efficient: -- -- > myUpdateDescriptorSets <- vkGetProc @VkUpdateDescriptorSets -- -- __Note:__ @vkUpdateDescriptorSetsUnsafe@ and @vkUpdateDescriptorSetsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkUpdateDescriptorSets@ is an alias -- of @vkUpdateDescriptorSetsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkUpdateDescriptorSetsSafe@. -- vkUpdateDescriptorSets :: VkDevice -- ^ device -> Word32 -- ^ descriptorWriteCount -> Ptr VkWriteDescriptorSet -- ^ pDescriptorWrites -> Word32 -- ^ descriptorCopyCount -> Ptr VkCopyDescriptorSet -- ^ pDescriptorCopies -> IO () #ifdef UNSAFE_FFI_DEFAULT vkUpdateDescriptorSets = vkUpdateDescriptorSetsUnsafe #else vkUpdateDescriptorSets = vkUpdateDescriptorSetsSafe #endif {-# INLINE vkUpdateDescriptorSets #-} -- | > void vkUpdateDescriptorSets -- > ( VkDevice device -- > , uint32_t descriptorWriteCount -- > , const VkWriteDescriptorSet* pDescriptorWrites -- > , uint32_t descriptorCopyCount -- > , const VkCopyDescriptorSet* pDescriptorCopies -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkUpdateDescriptorSets vkUpdateDescriptorSets registry at www.khronos.org> type HS_vkUpdateDescriptorSets = VkDevice -- ^ device -> Word32 -- ^ descriptorWriteCount -> Ptr VkWriteDescriptorSet -- ^ pDescriptorWrites -> Word32 -- ^ descriptorCopyCount -> Ptr VkCopyDescriptorSet -- ^ pDescriptorCopies -> IO () type PFN_vkUpdateDescriptorSets = FunPtr HS_vkUpdateDescriptorSets foreign import ccall unsafe "dynamic" unwrapVkUpdateDescriptorSetsUnsafe :: PFN_vkUpdateDescriptorSets -> HS_vkUpdateDescriptorSets foreign import ccall safe "dynamic" unwrapVkUpdateDescriptorSetsSafe :: PFN_vkUpdateDescriptorSets -> HS_vkUpdateDescriptorSets instance VulkanProc "vkUpdateDescriptorSets" where type VkProcType "vkUpdateDescriptorSets" = HS_vkUpdateDescriptorSets vkProcSymbol = _VkUpdateDescriptorSets {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkUpdateDescriptorSetsUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkUpdateDescriptorSetsSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreateFramebuffer :: CString pattern VkCreateFramebuffer <- (is_VkCreateFramebuffer -> True) where VkCreateFramebuffer = _VkCreateFramebuffer {-# INLINE _VkCreateFramebuffer #-} _VkCreateFramebuffer :: CString _VkCreateFramebuffer = Ptr "vkCreateFramebuffer\NUL"# {-# INLINE is_VkCreateFramebuffer #-} is_VkCreateFramebuffer :: CString -> Bool is_VkCreateFramebuffer = (EQ ==) . cmpCStrings _VkCreateFramebuffer type VkCreateFramebuffer = "vkCreateFramebuffer" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateFramebuffer -- > ( VkDevice device -- > , const VkFramebufferCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkFramebuffer* pFramebuffer -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateFramebuffer vkCreateFramebuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateFramebuffer <- vkGetDeviceProc @VkCreateFramebuffer vkDevice -- -- or less efficient: -- -- > myCreateFramebuffer <- vkGetProc @VkCreateFramebuffer -- -- __Note:__ @vkCreateFramebufferUnsafe@ and @vkCreateFramebufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateFramebuffer@ is an alias -- of @vkCreateFramebufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateFramebufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateFramebuffer" vkCreateFramebufferUnsafe :: VkDevice -- ^ device -> Ptr VkFramebufferCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkFramebuffer -- ^ pFramebuffer -> IO VkResult #else vkCreateFramebufferUnsafe :: VkDevice -- ^ device -> Ptr VkFramebufferCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkFramebuffer -- ^ pFramebuffer -> IO VkResult vkCreateFramebufferUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateFramebuffer) {-# NOINLINE vkCreateFramebufferUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateFramebuffer -- > ( VkDevice device -- > , const VkFramebufferCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkFramebuffer* pFramebuffer -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateFramebuffer vkCreateFramebuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateFramebuffer <- vkGetDeviceProc @VkCreateFramebuffer vkDevice -- -- or less efficient: -- -- > myCreateFramebuffer <- vkGetProc @VkCreateFramebuffer -- -- __Note:__ @vkCreateFramebufferUnsafe@ and @vkCreateFramebufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateFramebuffer@ is an alias -- of @vkCreateFramebufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateFramebufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateFramebuffer" vkCreateFramebufferSafe :: VkDevice -- ^ device -> Ptr VkFramebufferCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkFramebuffer -- ^ pFramebuffer -> IO VkResult #else vkCreateFramebufferSafe :: VkDevice -- ^ device -> Ptr VkFramebufferCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkFramebuffer -- ^ pFramebuffer -> IO VkResult vkCreateFramebufferSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateFramebuffer) {-# NOINLINE vkCreateFramebufferSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateFramebuffer -- > ( VkDevice device -- > , const VkFramebufferCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkFramebuffer* pFramebuffer -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateFramebuffer vkCreateFramebuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateFramebuffer <- vkGetDeviceProc @VkCreateFramebuffer vkDevice -- -- or less efficient: -- -- > myCreateFramebuffer <- vkGetProc @VkCreateFramebuffer -- -- __Note:__ @vkCreateFramebufferUnsafe@ and @vkCreateFramebufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateFramebuffer@ is an alias -- of @vkCreateFramebufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateFramebufferSafe@. -- vkCreateFramebuffer :: VkDevice -- ^ device -> Ptr VkFramebufferCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkFramebuffer -- ^ pFramebuffer -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateFramebuffer = vkCreateFramebufferUnsafe #else vkCreateFramebuffer = vkCreateFramebufferSafe #endif {-# INLINE vkCreateFramebuffer #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateFramebuffer -- > ( VkDevice device -- > , const VkFramebufferCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkFramebuffer* pFramebuffer -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateFramebuffer vkCreateFramebuffer registry at www.khronos.org> type HS_vkCreateFramebuffer = VkDevice -- ^ device -> Ptr VkFramebufferCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkFramebuffer -- ^ pFramebuffer -> IO VkResult type PFN_vkCreateFramebuffer = FunPtr HS_vkCreateFramebuffer foreign import ccall unsafe "dynamic" unwrapVkCreateFramebufferUnsafe :: PFN_vkCreateFramebuffer -> HS_vkCreateFramebuffer foreign import ccall safe "dynamic" unwrapVkCreateFramebufferSafe :: PFN_vkCreateFramebuffer -> HS_vkCreateFramebuffer instance VulkanProc "vkCreateFramebuffer" where type VkProcType "vkCreateFramebuffer" = HS_vkCreateFramebuffer vkProcSymbol = _VkCreateFramebuffer {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateFramebufferUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateFramebufferSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroyFramebuffer :: CString pattern VkDestroyFramebuffer <- (is_VkDestroyFramebuffer -> True) where VkDestroyFramebuffer = _VkDestroyFramebuffer {-# INLINE _VkDestroyFramebuffer #-} _VkDestroyFramebuffer :: CString _VkDestroyFramebuffer = Ptr "vkDestroyFramebuffer\NUL"# {-# INLINE is_VkDestroyFramebuffer #-} is_VkDestroyFramebuffer :: CString -> Bool is_VkDestroyFramebuffer = (EQ ==) . cmpCStrings _VkDestroyFramebuffer type VkDestroyFramebuffer = "vkDestroyFramebuffer" -- | -- > void vkDestroyFramebuffer -- > ( VkDevice device -- > , VkFramebuffer framebuffer -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyFramebuffer vkDestroyFramebuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyFramebuffer <- vkGetDeviceProc @VkDestroyFramebuffer vkDevice -- -- or less efficient: -- -- > myDestroyFramebuffer <- vkGetProc @VkDestroyFramebuffer -- -- __Note:__ @vkDestroyFramebufferUnsafe@ and @vkDestroyFramebufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyFramebuffer@ is an alias -- of @vkDestroyFramebufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyFramebufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroyFramebuffer" vkDestroyFramebufferUnsafe :: VkDevice -- ^ device -> VkFramebuffer -- ^ framebuffer -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyFramebufferUnsafe :: VkDevice -- ^ device -> VkFramebuffer -- ^ framebuffer -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyFramebufferUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroyFramebuffer) {-# NOINLINE vkDestroyFramebufferUnsafe #-} #endif -- | -- > void vkDestroyFramebuffer -- > ( VkDevice device -- > , VkFramebuffer framebuffer -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyFramebuffer vkDestroyFramebuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyFramebuffer <- vkGetDeviceProc @VkDestroyFramebuffer vkDevice -- -- or less efficient: -- -- > myDestroyFramebuffer <- vkGetProc @VkDestroyFramebuffer -- -- __Note:__ @vkDestroyFramebufferUnsafe@ and @vkDestroyFramebufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyFramebuffer@ is an alias -- of @vkDestroyFramebufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyFramebufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroyFramebuffer" vkDestroyFramebufferSafe :: VkDevice -- ^ device -> VkFramebuffer -- ^ framebuffer -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyFramebufferSafe :: VkDevice -- ^ device -> VkFramebuffer -- ^ framebuffer -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyFramebufferSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroyFramebuffer) {-# NOINLINE vkDestroyFramebufferSafe #-} #endif -- | -- > void vkDestroyFramebuffer -- > ( VkDevice device -- > , VkFramebuffer framebuffer -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyFramebuffer vkDestroyFramebuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyFramebuffer <- vkGetDeviceProc @VkDestroyFramebuffer vkDevice -- -- or less efficient: -- -- > myDestroyFramebuffer <- vkGetProc @VkDestroyFramebuffer -- -- __Note:__ @vkDestroyFramebufferUnsafe@ and @vkDestroyFramebufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyFramebuffer@ is an alias -- of @vkDestroyFramebufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyFramebufferSafe@. -- vkDestroyFramebuffer :: VkDevice -- ^ device -> VkFramebuffer -- ^ framebuffer -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroyFramebuffer = vkDestroyFramebufferUnsafe #else vkDestroyFramebuffer = vkDestroyFramebufferSafe #endif {-# INLINE vkDestroyFramebuffer #-} -- | > void vkDestroyFramebuffer -- > ( VkDevice device -- > , VkFramebuffer framebuffer -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyFramebuffer vkDestroyFramebuffer registry at www.khronos.org> type HS_vkDestroyFramebuffer = VkDevice -- ^ device -> VkFramebuffer -- ^ framebuffer -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroyFramebuffer = FunPtr HS_vkDestroyFramebuffer foreign import ccall unsafe "dynamic" unwrapVkDestroyFramebufferUnsafe :: PFN_vkDestroyFramebuffer -> HS_vkDestroyFramebuffer foreign import ccall safe "dynamic" unwrapVkDestroyFramebufferSafe :: PFN_vkDestroyFramebuffer -> HS_vkDestroyFramebuffer instance VulkanProc "vkDestroyFramebuffer" where type VkProcType "vkDestroyFramebuffer" = HS_vkDestroyFramebuffer vkProcSymbol = _VkDestroyFramebuffer {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroyFramebufferUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroyFramebufferSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreateRenderPass :: CString pattern VkCreateRenderPass <- (is_VkCreateRenderPass -> True) where VkCreateRenderPass = _VkCreateRenderPass {-# INLINE _VkCreateRenderPass #-} _VkCreateRenderPass :: CString _VkCreateRenderPass = Ptr "vkCreateRenderPass\NUL"# {-# INLINE is_VkCreateRenderPass #-} is_VkCreateRenderPass :: CString -> Bool is_VkCreateRenderPass = (EQ ==) . cmpCStrings _VkCreateRenderPass type VkCreateRenderPass = "vkCreateRenderPass" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateRenderPass -- > ( VkDevice device -- > , const VkRenderPassCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkRenderPass* pRenderPass -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateRenderPass vkCreateRenderPass registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateRenderPass <- vkGetDeviceProc @VkCreateRenderPass vkDevice -- -- or less efficient: -- -- > myCreateRenderPass <- vkGetProc @VkCreateRenderPass -- -- __Note:__ @vkCreateRenderPassUnsafe@ and @vkCreateRenderPassSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateRenderPass@ is an alias -- of @vkCreateRenderPassUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateRenderPassSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateRenderPass" vkCreateRenderPassUnsafe :: VkDevice -- ^ device -> Ptr VkRenderPassCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkRenderPass -- ^ pRenderPass -> IO VkResult #else vkCreateRenderPassUnsafe :: VkDevice -- ^ device -> Ptr VkRenderPassCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkRenderPass -- ^ pRenderPass -> IO VkResult vkCreateRenderPassUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateRenderPass) {-# NOINLINE vkCreateRenderPassUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateRenderPass -- > ( VkDevice device -- > , const VkRenderPassCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkRenderPass* pRenderPass -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateRenderPass vkCreateRenderPass registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateRenderPass <- vkGetDeviceProc @VkCreateRenderPass vkDevice -- -- or less efficient: -- -- > myCreateRenderPass <- vkGetProc @VkCreateRenderPass -- -- __Note:__ @vkCreateRenderPassUnsafe@ and @vkCreateRenderPassSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateRenderPass@ is an alias -- of @vkCreateRenderPassUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateRenderPassSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateRenderPass" vkCreateRenderPassSafe :: VkDevice -- ^ device -> Ptr VkRenderPassCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkRenderPass -- ^ pRenderPass -> IO VkResult #else vkCreateRenderPassSafe :: VkDevice -- ^ device -> Ptr VkRenderPassCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkRenderPass -- ^ pRenderPass -> IO VkResult vkCreateRenderPassSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateRenderPass) {-# NOINLINE vkCreateRenderPassSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateRenderPass -- > ( VkDevice device -- > , const VkRenderPassCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkRenderPass* pRenderPass -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateRenderPass vkCreateRenderPass registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateRenderPass <- vkGetDeviceProc @VkCreateRenderPass vkDevice -- -- or less efficient: -- -- > myCreateRenderPass <- vkGetProc @VkCreateRenderPass -- -- __Note:__ @vkCreateRenderPassUnsafe@ and @vkCreateRenderPassSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateRenderPass@ is an alias -- of @vkCreateRenderPassUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateRenderPassSafe@. -- vkCreateRenderPass :: VkDevice -- ^ device -> Ptr VkRenderPassCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkRenderPass -- ^ pRenderPass -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateRenderPass = vkCreateRenderPassUnsafe #else vkCreateRenderPass = vkCreateRenderPassSafe #endif {-# INLINE vkCreateRenderPass #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateRenderPass -- > ( VkDevice device -- > , const VkRenderPassCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkRenderPass* pRenderPass -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateRenderPass vkCreateRenderPass registry at www.khronos.org> type HS_vkCreateRenderPass = VkDevice -- ^ device -> Ptr VkRenderPassCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkRenderPass -- ^ pRenderPass -> IO VkResult type PFN_vkCreateRenderPass = FunPtr HS_vkCreateRenderPass foreign import ccall unsafe "dynamic" unwrapVkCreateRenderPassUnsafe :: PFN_vkCreateRenderPass -> HS_vkCreateRenderPass foreign import ccall safe "dynamic" unwrapVkCreateRenderPassSafe :: PFN_vkCreateRenderPass -> HS_vkCreateRenderPass instance VulkanProc "vkCreateRenderPass" where type VkProcType "vkCreateRenderPass" = HS_vkCreateRenderPass vkProcSymbol = _VkCreateRenderPass {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateRenderPassUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateRenderPassSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroyRenderPass :: CString pattern VkDestroyRenderPass <- (is_VkDestroyRenderPass -> True) where VkDestroyRenderPass = _VkDestroyRenderPass {-# INLINE _VkDestroyRenderPass #-} _VkDestroyRenderPass :: CString _VkDestroyRenderPass = Ptr "vkDestroyRenderPass\NUL"# {-# INLINE is_VkDestroyRenderPass #-} is_VkDestroyRenderPass :: CString -> Bool is_VkDestroyRenderPass = (EQ ==) . cmpCStrings _VkDestroyRenderPass type VkDestroyRenderPass = "vkDestroyRenderPass" -- | -- > void vkDestroyRenderPass -- > ( VkDevice device -- > , VkRenderPass renderPass -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyRenderPass vkDestroyRenderPass registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyRenderPass <- vkGetDeviceProc @VkDestroyRenderPass vkDevice -- -- or less efficient: -- -- > myDestroyRenderPass <- vkGetProc @VkDestroyRenderPass -- -- __Note:__ @vkDestroyRenderPassUnsafe@ and @vkDestroyRenderPassSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyRenderPass@ is an alias -- of @vkDestroyRenderPassUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyRenderPassSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroyRenderPass" vkDestroyRenderPassUnsafe :: VkDevice -- ^ device -> VkRenderPass -- ^ renderPass -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyRenderPassUnsafe :: VkDevice -- ^ device -> VkRenderPass -- ^ renderPass -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyRenderPassUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroyRenderPass) {-# NOINLINE vkDestroyRenderPassUnsafe #-} #endif -- | -- > void vkDestroyRenderPass -- > ( VkDevice device -- > , VkRenderPass renderPass -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyRenderPass vkDestroyRenderPass registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyRenderPass <- vkGetDeviceProc @VkDestroyRenderPass vkDevice -- -- or less efficient: -- -- > myDestroyRenderPass <- vkGetProc @VkDestroyRenderPass -- -- __Note:__ @vkDestroyRenderPassUnsafe@ and @vkDestroyRenderPassSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyRenderPass@ is an alias -- of @vkDestroyRenderPassUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyRenderPassSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroyRenderPass" vkDestroyRenderPassSafe :: VkDevice -- ^ device -> VkRenderPass -- ^ renderPass -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyRenderPassSafe :: VkDevice -- ^ device -> VkRenderPass -- ^ renderPass -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyRenderPassSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroyRenderPass) {-# NOINLINE vkDestroyRenderPassSafe #-} #endif -- | -- > void vkDestroyRenderPass -- > ( VkDevice device -- > , VkRenderPass renderPass -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyRenderPass vkDestroyRenderPass registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyRenderPass <- vkGetDeviceProc @VkDestroyRenderPass vkDevice -- -- or less efficient: -- -- > myDestroyRenderPass <- vkGetProc @VkDestroyRenderPass -- -- __Note:__ @vkDestroyRenderPassUnsafe@ and @vkDestroyRenderPassSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyRenderPass@ is an alias -- of @vkDestroyRenderPassUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyRenderPassSafe@. -- vkDestroyRenderPass :: VkDevice -- ^ device -> VkRenderPass -- ^ renderPass -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroyRenderPass = vkDestroyRenderPassUnsafe #else vkDestroyRenderPass = vkDestroyRenderPassSafe #endif {-# INLINE vkDestroyRenderPass #-} -- | > void vkDestroyRenderPass -- > ( VkDevice device -- > , VkRenderPass renderPass -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyRenderPass vkDestroyRenderPass registry at www.khronos.org> type HS_vkDestroyRenderPass = VkDevice -- ^ device -> VkRenderPass -- ^ renderPass -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroyRenderPass = FunPtr HS_vkDestroyRenderPass foreign import ccall unsafe "dynamic" unwrapVkDestroyRenderPassUnsafe :: PFN_vkDestroyRenderPass -> HS_vkDestroyRenderPass foreign import ccall safe "dynamic" unwrapVkDestroyRenderPassSafe :: PFN_vkDestroyRenderPass -> HS_vkDestroyRenderPass instance VulkanProc "vkDestroyRenderPass" where type VkProcType "vkDestroyRenderPass" = HS_vkDestroyRenderPass vkProcSymbol = _VkDestroyRenderPass {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroyRenderPassUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroyRenderPassSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkGetRenderAreaGranularity :: CString pattern VkGetRenderAreaGranularity <- (is_VkGetRenderAreaGranularity -> True) where VkGetRenderAreaGranularity = _VkGetRenderAreaGranularity {-# INLINE _VkGetRenderAreaGranularity #-} _VkGetRenderAreaGranularity :: CString _VkGetRenderAreaGranularity = Ptr "vkGetRenderAreaGranularity\NUL"# {-# INLINE is_VkGetRenderAreaGranularity #-} is_VkGetRenderAreaGranularity :: CString -> Bool is_VkGetRenderAreaGranularity = (EQ ==) . cmpCStrings _VkGetRenderAreaGranularity type VkGetRenderAreaGranularity = "vkGetRenderAreaGranularity" -- | -- > void vkGetRenderAreaGranularity -- > ( VkDevice device -- > , VkRenderPass renderPass -- > , VkExtent2D* pGranularity -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetRenderAreaGranularity vkGetRenderAreaGranularity registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetRenderAreaGranularity <- vkGetDeviceProc @VkGetRenderAreaGranularity vkDevice -- -- or less efficient: -- -- > myGetRenderAreaGranularity <- vkGetProc @VkGetRenderAreaGranularity -- -- __Note:__ @vkGetRenderAreaGranularityUnsafe@ and @vkGetRenderAreaGranularitySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetRenderAreaGranularity@ is an alias -- of @vkGetRenderAreaGranularityUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetRenderAreaGranularitySafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkGetRenderAreaGranularity" vkGetRenderAreaGranularityUnsafe :: VkDevice -- ^ device -> VkRenderPass -- ^ renderPass -> Ptr VkExtent2D -- ^ pGranularity -> IO () #else vkGetRenderAreaGranularityUnsafe :: VkDevice -- ^ device -> VkRenderPass -- ^ renderPass -> Ptr VkExtent2D -- ^ pGranularity -> IO () vkGetRenderAreaGranularityUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkGetRenderAreaGranularity) {-# NOINLINE vkGetRenderAreaGranularityUnsafe #-} #endif -- | -- > void vkGetRenderAreaGranularity -- > ( VkDevice device -- > , VkRenderPass renderPass -- > , VkExtent2D* pGranularity -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetRenderAreaGranularity vkGetRenderAreaGranularity registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetRenderAreaGranularity <- vkGetDeviceProc @VkGetRenderAreaGranularity vkDevice -- -- or less efficient: -- -- > myGetRenderAreaGranularity <- vkGetProc @VkGetRenderAreaGranularity -- -- __Note:__ @vkGetRenderAreaGranularityUnsafe@ and @vkGetRenderAreaGranularitySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetRenderAreaGranularity@ is an alias -- of @vkGetRenderAreaGranularityUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetRenderAreaGranularitySafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkGetRenderAreaGranularity" vkGetRenderAreaGranularitySafe :: VkDevice -- ^ device -> VkRenderPass -- ^ renderPass -> Ptr VkExtent2D -- ^ pGranularity -> IO () #else vkGetRenderAreaGranularitySafe :: VkDevice -- ^ device -> VkRenderPass -- ^ renderPass -> Ptr VkExtent2D -- ^ pGranularity -> IO () vkGetRenderAreaGranularitySafe = unsafeDupablePerformIO (vkGetProcSafe @VkGetRenderAreaGranularity) {-# NOINLINE vkGetRenderAreaGranularitySafe #-} #endif -- | -- > void vkGetRenderAreaGranularity -- > ( VkDevice device -- > , VkRenderPass renderPass -- > , VkExtent2D* pGranularity -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetRenderAreaGranularity vkGetRenderAreaGranularity registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myGetRenderAreaGranularity <- vkGetDeviceProc @VkGetRenderAreaGranularity vkDevice -- -- or less efficient: -- -- > myGetRenderAreaGranularity <- vkGetProc @VkGetRenderAreaGranularity -- -- __Note:__ @vkGetRenderAreaGranularityUnsafe@ and @vkGetRenderAreaGranularitySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkGetRenderAreaGranularity@ is an alias -- of @vkGetRenderAreaGranularityUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkGetRenderAreaGranularitySafe@. -- vkGetRenderAreaGranularity :: VkDevice -- ^ device -> VkRenderPass -- ^ renderPass -> Ptr VkExtent2D -- ^ pGranularity -> IO () #ifdef UNSAFE_FFI_DEFAULT vkGetRenderAreaGranularity = vkGetRenderAreaGranularityUnsafe #else vkGetRenderAreaGranularity = vkGetRenderAreaGranularitySafe #endif {-# INLINE vkGetRenderAreaGranularity #-} -- | > void vkGetRenderAreaGranularity -- > ( VkDevice device -- > , VkRenderPass renderPass -- > , VkExtent2D* pGranularity -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkGetRenderAreaGranularity vkGetRenderAreaGranularity registry at www.khronos.org> type HS_vkGetRenderAreaGranularity = VkDevice -- ^ device -> VkRenderPass -- ^ renderPass -> Ptr VkExtent2D -- ^ pGranularity -> IO () type PFN_vkGetRenderAreaGranularity = FunPtr HS_vkGetRenderAreaGranularity foreign import ccall unsafe "dynamic" unwrapVkGetRenderAreaGranularityUnsafe :: PFN_vkGetRenderAreaGranularity -> HS_vkGetRenderAreaGranularity foreign import ccall safe "dynamic" unwrapVkGetRenderAreaGranularitySafe :: PFN_vkGetRenderAreaGranularity -> HS_vkGetRenderAreaGranularity instance VulkanProc "vkGetRenderAreaGranularity" where type VkProcType "vkGetRenderAreaGranularity" = HS_vkGetRenderAreaGranularity vkProcSymbol = _VkGetRenderAreaGranularity {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkGetRenderAreaGranularityUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkGetRenderAreaGranularitySafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCreateCommandPool :: CString pattern VkCreateCommandPool <- (is_VkCreateCommandPool -> True) where VkCreateCommandPool = _VkCreateCommandPool {-# INLINE _VkCreateCommandPool #-} _VkCreateCommandPool :: CString _VkCreateCommandPool = Ptr "vkCreateCommandPool\NUL"# {-# INLINE is_VkCreateCommandPool #-} is_VkCreateCommandPool :: CString -> Bool is_VkCreateCommandPool = (EQ ==) . cmpCStrings _VkCreateCommandPool type VkCreateCommandPool = "vkCreateCommandPool" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateCommandPool -- > ( VkDevice device -- > , const VkCommandPoolCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkCommandPool* pCommandPool -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateCommandPool vkCreateCommandPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateCommandPool <- vkGetDeviceProc @VkCreateCommandPool vkDevice -- -- or less efficient: -- -- > myCreateCommandPool <- vkGetProc @VkCreateCommandPool -- -- __Note:__ @vkCreateCommandPoolUnsafe@ and @vkCreateCommandPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateCommandPool@ is an alias -- of @vkCreateCommandPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateCommandPoolSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCreateCommandPool" vkCreateCommandPoolUnsafe :: VkDevice -- ^ device -> Ptr VkCommandPoolCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkCommandPool -- ^ pCommandPool -> IO VkResult #else vkCreateCommandPoolUnsafe :: VkDevice -- ^ device -> Ptr VkCommandPoolCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkCommandPool -- ^ pCommandPool -> IO VkResult vkCreateCommandPoolUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCreateCommandPool) {-# NOINLINE vkCreateCommandPoolUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateCommandPool -- > ( VkDevice device -- > , const VkCommandPoolCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkCommandPool* pCommandPool -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateCommandPool vkCreateCommandPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateCommandPool <- vkGetDeviceProc @VkCreateCommandPool vkDevice -- -- or less efficient: -- -- > myCreateCommandPool <- vkGetProc @VkCreateCommandPool -- -- __Note:__ @vkCreateCommandPoolUnsafe@ and @vkCreateCommandPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateCommandPool@ is an alias -- of @vkCreateCommandPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateCommandPoolSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCreateCommandPool" vkCreateCommandPoolSafe :: VkDevice -- ^ device -> Ptr VkCommandPoolCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkCommandPool -- ^ pCommandPool -> IO VkResult #else vkCreateCommandPoolSafe :: VkDevice -- ^ device -> Ptr VkCommandPoolCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkCommandPool -- ^ pCommandPool -> IO VkResult vkCreateCommandPoolSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCreateCommandPool) {-# NOINLINE vkCreateCommandPoolSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateCommandPool -- > ( VkDevice device -- > , const VkCommandPoolCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkCommandPool* pCommandPool -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateCommandPool vkCreateCommandPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCreateCommandPool <- vkGetDeviceProc @VkCreateCommandPool vkDevice -- -- or less efficient: -- -- > myCreateCommandPool <- vkGetProc @VkCreateCommandPool -- -- __Note:__ @vkCreateCommandPoolUnsafe@ and @vkCreateCommandPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCreateCommandPool@ is an alias -- of @vkCreateCommandPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCreateCommandPoolSafe@. -- vkCreateCommandPool :: VkDevice -- ^ device -> Ptr VkCommandPoolCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkCommandPool -- ^ pCommandPool -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkCreateCommandPool = vkCreateCommandPoolUnsafe #else vkCreateCommandPool = vkCreateCommandPoolSafe #endif {-# INLINE vkCreateCommandPool #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkCreateCommandPool -- > ( VkDevice device -- > , const VkCommandPoolCreateInfo* pCreateInfo -- > , const VkAllocationCallbacks* pAllocator -- > , VkCommandPool* pCommandPool -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCreateCommandPool vkCreateCommandPool registry at www.khronos.org> type HS_vkCreateCommandPool = VkDevice -- ^ device -> Ptr VkCommandPoolCreateInfo -- ^ pCreateInfo -> Ptr VkAllocationCallbacks -- ^ pAllocator -> Ptr VkCommandPool -- ^ pCommandPool -> IO VkResult type PFN_vkCreateCommandPool = FunPtr HS_vkCreateCommandPool foreign import ccall unsafe "dynamic" unwrapVkCreateCommandPoolUnsafe :: PFN_vkCreateCommandPool -> HS_vkCreateCommandPool foreign import ccall safe "dynamic" unwrapVkCreateCommandPoolSafe :: PFN_vkCreateCommandPool -> HS_vkCreateCommandPool instance VulkanProc "vkCreateCommandPool" where type VkProcType "vkCreateCommandPool" = HS_vkCreateCommandPool vkProcSymbol = _VkCreateCommandPool {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCreateCommandPoolUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCreateCommandPoolSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkDestroyCommandPool :: CString pattern VkDestroyCommandPool <- (is_VkDestroyCommandPool -> True) where VkDestroyCommandPool = _VkDestroyCommandPool {-# INLINE _VkDestroyCommandPool #-} _VkDestroyCommandPool :: CString _VkDestroyCommandPool = Ptr "vkDestroyCommandPool\NUL"# {-# INLINE is_VkDestroyCommandPool #-} is_VkDestroyCommandPool :: CString -> Bool is_VkDestroyCommandPool = (EQ ==) . cmpCStrings _VkDestroyCommandPool type VkDestroyCommandPool = "vkDestroyCommandPool" -- | -- > void vkDestroyCommandPool -- > ( VkDevice device -- > , VkCommandPool commandPool -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyCommandPool vkDestroyCommandPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyCommandPool <- vkGetDeviceProc @VkDestroyCommandPool vkDevice -- -- or less efficient: -- -- > myDestroyCommandPool <- vkGetProc @VkDestroyCommandPool -- -- __Note:__ @vkDestroyCommandPoolUnsafe@ and @vkDestroyCommandPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyCommandPool@ is an alias -- of @vkDestroyCommandPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyCommandPoolSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkDestroyCommandPool" vkDestroyCommandPoolUnsafe :: VkDevice -- ^ device -> VkCommandPool -- ^ commandPool -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyCommandPoolUnsafe :: VkDevice -- ^ device -> VkCommandPool -- ^ commandPool -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyCommandPoolUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkDestroyCommandPool) {-# NOINLINE vkDestroyCommandPoolUnsafe #-} #endif -- | -- > void vkDestroyCommandPool -- > ( VkDevice device -- > , VkCommandPool commandPool -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyCommandPool vkDestroyCommandPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyCommandPool <- vkGetDeviceProc @VkDestroyCommandPool vkDevice -- -- or less efficient: -- -- > myDestroyCommandPool <- vkGetProc @VkDestroyCommandPool -- -- __Note:__ @vkDestroyCommandPoolUnsafe@ and @vkDestroyCommandPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyCommandPool@ is an alias -- of @vkDestroyCommandPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyCommandPoolSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkDestroyCommandPool" vkDestroyCommandPoolSafe :: VkDevice -- ^ device -> VkCommandPool -- ^ commandPool -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #else vkDestroyCommandPoolSafe :: VkDevice -- ^ device -> VkCommandPool -- ^ commandPool -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () vkDestroyCommandPoolSafe = unsafeDupablePerformIO (vkGetProcSafe @VkDestroyCommandPool) {-# NOINLINE vkDestroyCommandPoolSafe #-} #endif -- | -- > void vkDestroyCommandPool -- > ( VkDevice device -- > , VkCommandPool commandPool -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyCommandPool vkDestroyCommandPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myDestroyCommandPool <- vkGetDeviceProc @VkDestroyCommandPool vkDevice -- -- or less efficient: -- -- > myDestroyCommandPool <- vkGetProc @VkDestroyCommandPool -- -- __Note:__ @vkDestroyCommandPoolUnsafe@ and @vkDestroyCommandPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkDestroyCommandPool@ is an alias -- of @vkDestroyCommandPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkDestroyCommandPoolSafe@. -- vkDestroyCommandPool :: VkDevice -- ^ device -> VkCommandPool -- ^ commandPool -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () #ifdef UNSAFE_FFI_DEFAULT vkDestroyCommandPool = vkDestroyCommandPoolUnsafe #else vkDestroyCommandPool = vkDestroyCommandPoolSafe #endif {-# INLINE vkDestroyCommandPool #-} -- | > void vkDestroyCommandPool -- > ( VkDevice device -- > , VkCommandPool commandPool -- > , const VkAllocationCallbacks* pAllocator -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkDestroyCommandPool vkDestroyCommandPool registry at www.khronos.org> type HS_vkDestroyCommandPool = VkDevice -- ^ device -> VkCommandPool -- ^ commandPool -> Ptr VkAllocationCallbacks -- ^ pAllocator -> IO () type PFN_vkDestroyCommandPool = FunPtr HS_vkDestroyCommandPool foreign import ccall unsafe "dynamic" unwrapVkDestroyCommandPoolUnsafe :: PFN_vkDestroyCommandPool -> HS_vkDestroyCommandPool foreign import ccall safe "dynamic" unwrapVkDestroyCommandPoolSafe :: PFN_vkDestroyCommandPool -> HS_vkDestroyCommandPool instance VulkanProc "vkDestroyCommandPool" where type VkProcType "vkDestroyCommandPool" = HS_vkDestroyCommandPool vkProcSymbol = _VkDestroyCommandPool {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkDestroyCommandPoolUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkDestroyCommandPoolSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkResetCommandPool :: CString pattern VkResetCommandPool <- (is_VkResetCommandPool -> True) where VkResetCommandPool = _VkResetCommandPool {-# INLINE _VkResetCommandPool #-} _VkResetCommandPool :: CString _VkResetCommandPool = Ptr "vkResetCommandPool\NUL"# {-# INLINE is_VkResetCommandPool #-} is_VkResetCommandPool :: CString -> Bool is_VkResetCommandPool = (EQ ==) . cmpCStrings _VkResetCommandPool type VkResetCommandPool = "vkResetCommandPool" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkResetCommandPool -- > ( VkDevice device -- > , VkCommandPool commandPool -- > , VkCommandPoolResetFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetCommandPool vkResetCommandPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myResetCommandPool <- vkGetDeviceProc @VkResetCommandPool vkDevice -- -- or less efficient: -- -- > myResetCommandPool <- vkGetProc @VkResetCommandPool -- -- __Note:__ @vkResetCommandPoolUnsafe@ and @vkResetCommandPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkResetCommandPool@ is an alias -- of @vkResetCommandPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkResetCommandPoolSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkResetCommandPool" vkResetCommandPoolUnsafe :: VkDevice -- ^ device -> VkCommandPool -- ^ commandPool -> VkCommandPoolResetFlags -- ^ flags -> IO VkResult #else vkResetCommandPoolUnsafe :: VkDevice -- ^ device -> VkCommandPool -- ^ commandPool -> VkCommandPoolResetFlags -- ^ flags -> IO VkResult vkResetCommandPoolUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkResetCommandPool) {-# NOINLINE vkResetCommandPoolUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkResetCommandPool -- > ( VkDevice device -- > , VkCommandPool commandPool -- > , VkCommandPoolResetFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetCommandPool vkResetCommandPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myResetCommandPool <- vkGetDeviceProc @VkResetCommandPool vkDevice -- -- or less efficient: -- -- > myResetCommandPool <- vkGetProc @VkResetCommandPool -- -- __Note:__ @vkResetCommandPoolUnsafe@ and @vkResetCommandPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkResetCommandPool@ is an alias -- of @vkResetCommandPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkResetCommandPoolSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkResetCommandPool" vkResetCommandPoolSafe :: VkDevice -- ^ device -> VkCommandPool -- ^ commandPool -> VkCommandPoolResetFlags -- ^ flags -> IO VkResult #else vkResetCommandPoolSafe :: VkDevice -- ^ device -> VkCommandPool -- ^ commandPool -> VkCommandPoolResetFlags -- ^ flags -> IO VkResult vkResetCommandPoolSafe = unsafeDupablePerformIO (vkGetProcSafe @VkResetCommandPool) {-# NOINLINE vkResetCommandPoolSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkResetCommandPool -- > ( VkDevice device -- > , VkCommandPool commandPool -- > , VkCommandPoolResetFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetCommandPool vkResetCommandPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myResetCommandPool <- vkGetDeviceProc @VkResetCommandPool vkDevice -- -- or less efficient: -- -- > myResetCommandPool <- vkGetProc @VkResetCommandPool -- -- __Note:__ @vkResetCommandPoolUnsafe@ and @vkResetCommandPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkResetCommandPool@ is an alias -- of @vkResetCommandPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkResetCommandPoolSafe@. -- vkResetCommandPool :: VkDevice -- ^ device -> VkCommandPool -- ^ commandPool -> VkCommandPoolResetFlags -- ^ flags -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkResetCommandPool = vkResetCommandPoolUnsafe #else vkResetCommandPool = vkResetCommandPoolSafe #endif {-# INLINE vkResetCommandPool #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkResetCommandPool -- > ( VkDevice device -- > , VkCommandPool commandPool -- > , VkCommandPoolResetFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetCommandPool vkResetCommandPool registry at www.khronos.org> type HS_vkResetCommandPool = VkDevice -- ^ device -> VkCommandPool -- ^ commandPool -> VkCommandPoolResetFlags -- ^ flags -> IO VkResult type PFN_vkResetCommandPool = FunPtr HS_vkResetCommandPool foreign import ccall unsafe "dynamic" unwrapVkResetCommandPoolUnsafe :: PFN_vkResetCommandPool -> HS_vkResetCommandPool foreign import ccall safe "dynamic" unwrapVkResetCommandPoolSafe :: PFN_vkResetCommandPool -> HS_vkResetCommandPool instance VulkanProc "vkResetCommandPool" where type VkProcType "vkResetCommandPool" = HS_vkResetCommandPool vkProcSymbol = _VkResetCommandPool {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkResetCommandPoolUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkResetCommandPoolSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkAllocateCommandBuffers :: CString pattern VkAllocateCommandBuffers <- (is_VkAllocateCommandBuffers -> True) where VkAllocateCommandBuffers = _VkAllocateCommandBuffers {-# INLINE _VkAllocateCommandBuffers #-} _VkAllocateCommandBuffers :: CString _VkAllocateCommandBuffers = Ptr "vkAllocateCommandBuffers\NUL"# {-# INLINE is_VkAllocateCommandBuffers #-} is_VkAllocateCommandBuffers :: CString -> Bool is_VkAllocateCommandBuffers = (EQ ==) . cmpCStrings _VkAllocateCommandBuffers type VkAllocateCommandBuffers = "vkAllocateCommandBuffers" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkAllocateCommandBuffers -- > ( VkDevice device -- > , const VkCommandBufferAllocateInfo* pAllocateInfo -- > , VkCommandBuffer* pCommandBuffers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkAllocateCommandBuffers vkAllocateCommandBuffers registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myAllocateCommandBuffers <- vkGetDeviceProc @VkAllocateCommandBuffers vkDevice -- -- or less efficient: -- -- > myAllocateCommandBuffers <- vkGetProc @VkAllocateCommandBuffers -- -- __Note:__ @vkAllocateCommandBuffersUnsafe@ and @vkAllocateCommandBuffersSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkAllocateCommandBuffers@ is an alias -- of @vkAllocateCommandBuffersUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkAllocateCommandBuffersSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkAllocateCommandBuffers" vkAllocateCommandBuffersUnsafe :: VkDevice -- ^ device -> Ptr VkCommandBufferAllocateInfo -- ^ pAllocateInfo -> Ptr VkCommandBuffer -- ^ pCommandBuffers -> IO VkResult #else vkAllocateCommandBuffersUnsafe :: VkDevice -- ^ device -> Ptr VkCommandBufferAllocateInfo -- ^ pAllocateInfo -> Ptr VkCommandBuffer -- ^ pCommandBuffers -> IO VkResult vkAllocateCommandBuffersUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkAllocateCommandBuffers) {-# NOINLINE vkAllocateCommandBuffersUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkAllocateCommandBuffers -- > ( VkDevice device -- > , const VkCommandBufferAllocateInfo* pAllocateInfo -- > , VkCommandBuffer* pCommandBuffers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkAllocateCommandBuffers vkAllocateCommandBuffers registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myAllocateCommandBuffers <- vkGetDeviceProc @VkAllocateCommandBuffers vkDevice -- -- or less efficient: -- -- > myAllocateCommandBuffers <- vkGetProc @VkAllocateCommandBuffers -- -- __Note:__ @vkAllocateCommandBuffersUnsafe@ and @vkAllocateCommandBuffersSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkAllocateCommandBuffers@ is an alias -- of @vkAllocateCommandBuffersUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkAllocateCommandBuffersSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkAllocateCommandBuffers" vkAllocateCommandBuffersSafe :: VkDevice -- ^ device -> Ptr VkCommandBufferAllocateInfo -- ^ pAllocateInfo -> Ptr VkCommandBuffer -- ^ pCommandBuffers -> IO VkResult #else vkAllocateCommandBuffersSafe :: VkDevice -- ^ device -> Ptr VkCommandBufferAllocateInfo -- ^ pAllocateInfo -> Ptr VkCommandBuffer -- ^ pCommandBuffers -> IO VkResult vkAllocateCommandBuffersSafe = unsafeDupablePerformIO (vkGetProcSafe @VkAllocateCommandBuffers) {-# NOINLINE vkAllocateCommandBuffersSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkAllocateCommandBuffers -- > ( VkDevice device -- > , const VkCommandBufferAllocateInfo* pAllocateInfo -- > , VkCommandBuffer* pCommandBuffers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkAllocateCommandBuffers vkAllocateCommandBuffers registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myAllocateCommandBuffers <- vkGetDeviceProc @VkAllocateCommandBuffers vkDevice -- -- or less efficient: -- -- > myAllocateCommandBuffers <- vkGetProc @VkAllocateCommandBuffers -- -- __Note:__ @vkAllocateCommandBuffersUnsafe@ and @vkAllocateCommandBuffersSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkAllocateCommandBuffers@ is an alias -- of @vkAllocateCommandBuffersUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkAllocateCommandBuffersSafe@. -- vkAllocateCommandBuffers :: VkDevice -- ^ device -> Ptr VkCommandBufferAllocateInfo -- ^ pAllocateInfo -> Ptr VkCommandBuffer -- ^ pCommandBuffers -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkAllocateCommandBuffers = vkAllocateCommandBuffersUnsafe #else vkAllocateCommandBuffers = vkAllocateCommandBuffersSafe #endif {-# INLINE vkAllocateCommandBuffers #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkAllocateCommandBuffers -- > ( VkDevice device -- > , const VkCommandBufferAllocateInfo* pAllocateInfo -- > , VkCommandBuffer* pCommandBuffers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkAllocateCommandBuffers vkAllocateCommandBuffers registry at www.khronos.org> type HS_vkAllocateCommandBuffers = VkDevice -- ^ device -> Ptr VkCommandBufferAllocateInfo -- ^ pAllocateInfo -> Ptr VkCommandBuffer -- ^ pCommandBuffers -> IO VkResult type PFN_vkAllocateCommandBuffers = FunPtr HS_vkAllocateCommandBuffers foreign import ccall unsafe "dynamic" unwrapVkAllocateCommandBuffersUnsafe :: PFN_vkAllocateCommandBuffers -> HS_vkAllocateCommandBuffers foreign import ccall safe "dynamic" unwrapVkAllocateCommandBuffersSafe :: PFN_vkAllocateCommandBuffers -> HS_vkAllocateCommandBuffers instance VulkanProc "vkAllocateCommandBuffers" where type VkProcType "vkAllocateCommandBuffers" = HS_vkAllocateCommandBuffers vkProcSymbol = _VkAllocateCommandBuffers {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkAllocateCommandBuffersUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkAllocateCommandBuffersSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkFreeCommandBuffers :: CString pattern VkFreeCommandBuffers <- (is_VkFreeCommandBuffers -> True) where VkFreeCommandBuffers = _VkFreeCommandBuffers {-# INLINE _VkFreeCommandBuffers #-} _VkFreeCommandBuffers :: CString _VkFreeCommandBuffers = Ptr "vkFreeCommandBuffers\NUL"# {-# INLINE is_VkFreeCommandBuffers #-} is_VkFreeCommandBuffers :: CString -> Bool is_VkFreeCommandBuffers = (EQ ==) . cmpCStrings _VkFreeCommandBuffers type VkFreeCommandBuffers = "vkFreeCommandBuffers" -- | -- > void vkFreeCommandBuffers -- > ( VkDevice device -- > , VkCommandPool commandPool -- > , uint32_t commandBufferCount -- > , const VkCommandBuffer* pCommandBuffers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkFreeCommandBuffers vkFreeCommandBuffers registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myFreeCommandBuffers <- vkGetDeviceProc @VkFreeCommandBuffers vkDevice -- -- or less efficient: -- -- > myFreeCommandBuffers <- vkGetProc @VkFreeCommandBuffers -- -- __Note:__ @vkFreeCommandBuffersUnsafe@ and @vkFreeCommandBuffersSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkFreeCommandBuffers@ is an alias -- of @vkFreeCommandBuffersUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkFreeCommandBuffersSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkFreeCommandBuffers" vkFreeCommandBuffersUnsafe :: VkDevice -- ^ device -> VkCommandPool -- ^ commandPool -> Word32 -- ^ commandBufferCount -> Ptr VkCommandBuffer -- ^ pCommandBuffers -> IO () #else vkFreeCommandBuffersUnsafe :: VkDevice -- ^ device -> VkCommandPool -- ^ commandPool -> Word32 -- ^ commandBufferCount -> Ptr VkCommandBuffer -- ^ pCommandBuffers -> IO () vkFreeCommandBuffersUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkFreeCommandBuffers) {-# NOINLINE vkFreeCommandBuffersUnsafe #-} #endif -- | -- > void vkFreeCommandBuffers -- > ( VkDevice device -- > , VkCommandPool commandPool -- > , uint32_t commandBufferCount -- > , const VkCommandBuffer* pCommandBuffers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkFreeCommandBuffers vkFreeCommandBuffers registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myFreeCommandBuffers <- vkGetDeviceProc @VkFreeCommandBuffers vkDevice -- -- or less efficient: -- -- > myFreeCommandBuffers <- vkGetProc @VkFreeCommandBuffers -- -- __Note:__ @vkFreeCommandBuffersUnsafe@ and @vkFreeCommandBuffersSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkFreeCommandBuffers@ is an alias -- of @vkFreeCommandBuffersUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkFreeCommandBuffersSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkFreeCommandBuffers" vkFreeCommandBuffersSafe :: VkDevice -- ^ device -> VkCommandPool -- ^ commandPool -> Word32 -- ^ commandBufferCount -> Ptr VkCommandBuffer -- ^ pCommandBuffers -> IO () #else vkFreeCommandBuffersSafe :: VkDevice -- ^ device -> VkCommandPool -- ^ commandPool -> Word32 -- ^ commandBufferCount -> Ptr VkCommandBuffer -- ^ pCommandBuffers -> IO () vkFreeCommandBuffersSafe = unsafeDupablePerformIO (vkGetProcSafe @VkFreeCommandBuffers) {-# NOINLINE vkFreeCommandBuffersSafe #-} #endif -- | -- > void vkFreeCommandBuffers -- > ( VkDevice device -- > , VkCommandPool commandPool -- > , uint32_t commandBufferCount -- > , const VkCommandBuffer* pCommandBuffers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkFreeCommandBuffers vkFreeCommandBuffers registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myFreeCommandBuffers <- vkGetDeviceProc @VkFreeCommandBuffers vkDevice -- -- or less efficient: -- -- > myFreeCommandBuffers <- vkGetProc @VkFreeCommandBuffers -- -- __Note:__ @vkFreeCommandBuffersUnsafe@ and @vkFreeCommandBuffersSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkFreeCommandBuffers@ is an alias -- of @vkFreeCommandBuffersUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkFreeCommandBuffersSafe@. -- vkFreeCommandBuffers :: VkDevice -- ^ device -> VkCommandPool -- ^ commandPool -> Word32 -- ^ commandBufferCount -> Ptr VkCommandBuffer -- ^ pCommandBuffers -> IO () #ifdef UNSAFE_FFI_DEFAULT vkFreeCommandBuffers = vkFreeCommandBuffersUnsafe #else vkFreeCommandBuffers = vkFreeCommandBuffersSafe #endif {-# INLINE vkFreeCommandBuffers #-} -- | > void vkFreeCommandBuffers -- > ( VkDevice device -- > , VkCommandPool commandPool -- > , uint32_t commandBufferCount -- > , const VkCommandBuffer* pCommandBuffers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkFreeCommandBuffers vkFreeCommandBuffers registry at www.khronos.org> type HS_vkFreeCommandBuffers = VkDevice -- ^ device -> VkCommandPool -- ^ commandPool -> Word32 -- ^ commandBufferCount -> Ptr VkCommandBuffer -- ^ pCommandBuffers -> IO () type PFN_vkFreeCommandBuffers = FunPtr HS_vkFreeCommandBuffers foreign import ccall unsafe "dynamic" unwrapVkFreeCommandBuffersUnsafe :: PFN_vkFreeCommandBuffers -> HS_vkFreeCommandBuffers foreign import ccall safe "dynamic" unwrapVkFreeCommandBuffersSafe :: PFN_vkFreeCommandBuffers -> HS_vkFreeCommandBuffers instance VulkanProc "vkFreeCommandBuffers" where type VkProcType "vkFreeCommandBuffers" = HS_vkFreeCommandBuffers vkProcSymbol = _VkFreeCommandBuffers {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkFreeCommandBuffersUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkFreeCommandBuffersSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkBeginCommandBuffer :: CString pattern VkBeginCommandBuffer <- (is_VkBeginCommandBuffer -> True) where VkBeginCommandBuffer = _VkBeginCommandBuffer {-# INLINE _VkBeginCommandBuffer #-} _VkBeginCommandBuffer :: CString _VkBeginCommandBuffer = Ptr "vkBeginCommandBuffer\NUL"# {-# INLINE is_VkBeginCommandBuffer #-} is_VkBeginCommandBuffer :: CString -> Bool is_VkBeginCommandBuffer = (EQ ==) . cmpCStrings _VkBeginCommandBuffer type VkBeginCommandBuffer = "vkBeginCommandBuffer" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkBeginCommandBuffer -- > ( VkCommandBuffer commandBuffer -- > , const VkCommandBufferBeginInfo* pBeginInfo -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBeginCommandBuffer vkBeginCommandBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myBeginCommandBuffer <- vkGetInstanceProc @VkBeginCommandBuffer vkInstance -- -- or less efficient: -- -- > myBeginCommandBuffer <- vkGetProc @VkBeginCommandBuffer -- -- __Note:__ @vkBeginCommandBufferUnsafe@ and @vkBeginCommandBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkBeginCommandBuffer@ is an alias -- of @vkBeginCommandBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkBeginCommandBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkBeginCommandBuffer" vkBeginCommandBufferUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Ptr VkCommandBufferBeginInfo -- ^ pBeginInfo -> IO VkResult #else vkBeginCommandBufferUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Ptr VkCommandBufferBeginInfo -- ^ pBeginInfo -> IO VkResult vkBeginCommandBufferUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkBeginCommandBuffer) {-# NOINLINE vkBeginCommandBufferUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkBeginCommandBuffer -- > ( VkCommandBuffer commandBuffer -- > , const VkCommandBufferBeginInfo* pBeginInfo -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBeginCommandBuffer vkBeginCommandBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myBeginCommandBuffer <- vkGetInstanceProc @VkBeginCommandBuffer vkInstance -- -- or less efficient: -- -- > myBeginCommandBuffer <- vkGetProc @VkBeginCommandBuffer -- -- __Note:__ @vkBeginCommandBufferUnsafe@ and @vkBeginCommandBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkBeginCommandBuffer@ is an alias -- of @vkBeginCommandBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkBeginCommandBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkBeginCommandBuffer" vkBeginCommandBufferSafe :: VkCommandBuffer -- ^ commandBuffer -> Ptr VkCommandBufferBeginInfo -- ^ pBeginInfo -> IO VkResult #else vkBeginCommandBufferSafe :: VkCommandBuffer -- ^ commandBuffer -> Ptr VkCommandBufferBeginInfo -- ^ pBeginInfo -> IO VkResult vkBeginCommandBufferSafe = unsafeDupablePerformIO (vkGetProcSafe @VkBeginCommandBuffer) {-# NOINLINE vkBeginCommandBufferSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkBeginCommandBuffer -- > ( VkCommandBuffer commandBuffer -- > , const VkCommandBufferBeginInfo* pBeginInfo -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBeginCommandBuffer vkBeginCommandBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myBeginCommandBuffer <- vkGetInstanceProc @VkBeginCommandBuffer vkInstance -- -- or less efficient: -- -- > myBeginCommandBuffer <- vkGetProc @VkBeginCommandBuffer -- -- __Note:__ @vkBeginCommandBufferUnsafe@ and @vkBeginCommandBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkBeginCommandBuffer@ is an alias -- of @vkBeginCommandBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkBeginCommandBufferSafe@. -- vkBeginCommandBuffer :: VkCommandBuffer -- ^ commandBuffer -> Ptr VkCommandBufferBeginInfo -- ^ pBeginInfo -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkBeginCommandBuffer = vkBeginCommandBufferUnsafe #else vkBeginCommandBuffer = vkBeginCommandBufferSafe #endif {-# INLINE vkBeginCommandBuffer #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkBeginCommandBuffer -- > ( VkCommandBuffer commandBuffer -- > , const VkCommandBufferBeginInfo* pBeginInfo -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkBeginCommandBuffer vkBeginCommandBuffer registry at www.khronos.org> type HS_vkBeginCommandBuffer = VkCommandBuffer -- ^ commandBuffer -> Ptr VkCommandBufferBeginInfo -- ^ pBeginInfo -> IO VkResult type PFN_vkBeginCommandBuffer = FunPtr HS_vkBeginCommandBuffer foreign import ccall unsafe "dynamic" unwrapVkBeginCommandBufferUnsafe :: PFN_vkBeginCommandBuffer -> HS_vkBeginCommandBuffer foreign import ccall safe "dynamic" unwrapVkBeginCommandBufferSafe :: PFN_vkBeginCommandBuffer -> HS_vkBeginCommandBuffer instance VulkanProc "vkBeginCommandBuffer" where type VkProcType "vkBeginCommandBuffer" = HS_vkBeginCommandBuffer vkProcSymbol = _VkBeginCommandBuffer {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkBeginCommandBufferUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkBeginCommandBufferSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkEndCommandBuffer :: CString pattern VkEndCommandBuffer <- (is_VkEndCommandBuffer -> True) where VkEndCommandBuffer = _VkEndCommandBuffer {-# INLINE _VkEndCommandBuffer #-} _VkEndCommandBuffer :: CString _VkEndCommandBuffer = Ptr "vkEndCommandBuffer\NUL"# {-# INLINE is_VkEndCommandBuffer #-} is_VkEndCommandBuffer :: CString -> Bool is_VkEndCommandBuffer = (EQ ==) . cmpCStrings _VkEndCommandBuffer type VkEndCommandBuffer = "vkEndCommandBuffer" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkEndCommandBuffer -- > ( VkCommandBuffer commandBuffer -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEndCommandBuffer vkEndCommandBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myEndCommandBuffer <- vkGetInstanceProc @VkEndCommandBuffer vkInstance -- -- or less efficient: -- -- > myEndCommandBuffer <- vkGetProc @VkEndCommandBuffer -- -- __Note:__ @vkEndCommandBufferUnsafe@ and @vkEndCommandBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkEndCommandBuffer@ is an alias -- of @vkEndCommandBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkEndCommandBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkEndCommandBuffer" vkEndCommandBufferUnsafe :: VkCommandBuffer -- ^ commandBuffer -> IO VkResult #else vkEndCommandBufferUnsafe :: VkCommandBuffer -- ^ commandBuffer -> IO VkResult vkEndCommandBufferUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkEndCommandBuffer) {-# NOINLINE vkEndCommandBufferUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkEndCommandBuffer -- > ( VkCommandBuffer commandBuffer -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEndCommandBuffer vkEndCommandBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myEndCommandBuffer <- vkGetInstanceProc @VkEndCommandBuffer vkInstance -- -- or less efficient: -- -- > myEndCommandBuffer <- vkGetProc @VkEndCommandBuffer -- -- __Note:__ @vkEndCommandBufferUnsafe@ and @vkEndCommandBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkEndCommandBuffer@ is an alias -- of @vkEndCommandBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkEndCommandBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkEndCommandBuffer" vkEndCommandBufferSafe :: VkCommandBuffer -- ^ commandBuffer -> IO VkResult #else vkEndCommandBufferSafe :: VkCommandBuffer -- ^ commandBuffer -> IO VkResult vkEndCommandBufferSafe = unsafeDupablePerformIO (vkGetProcSafe @VkEndCommandBuffer) {-# NOINLINE vkEndCommandBufferSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkEndCommandBuffer -- > ( VkCommandBuffer commandBuffer -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEndCommandBuffer vkEndCommandBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myEndCommandBuffer <- vkGetInstanceProc @VkEndCommandBuffer vkInstance -- -- or less efficient: -- -- > myEndCommandBuffer <- vkGetProc @VkEndCommandBuffer -- -- __Note:__ @vkEndCommandBufferUnsafe@ and @vkEndCommandBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkEndCommandBuffer@ is an alias -- of @vkEndCommandBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkEndCommandBufferSafe@. -- vkEndCommandBuffer :: VkCommandBuffer -- ^ commandBuffer -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkEndCommandBuffer = vkEndCommandBufferUnsafe #else vkEndCommandBuffer = vkEndCommandBufferSafe #endif {-# INLINE vkEndCommandBuffer #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkEndCommandBuffer -- > ( VkCommandBuffer commandBuffer -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkEndCommandBuffer vkEndCommandBuffer registry at www.khronos.org> type HS_vkEndCommandBuffer = VkCommandBuffer -- ^ commandBuffer -> IO VkResult type PFN_vkEndCommandBuffer = FunPtr HS_vkEndCommandBuffer foreign import ccall unsafe "dynamic" unwrapVkEndCommandBufferUnsafe :: PFN_vkEndCommandBuffer -> HS_vkEndCommandBuffer foreign import ccall safe "dynamic" unwrapVkEndCommandBufferSafe :: PFN_vkEndCommandBuffer -> HS_vkEndCommandBuffer instance VulkanProc "vkEndCommandBuffer" where type VkProcType "vkEndCommandBuffer" = HS_vkEndCommandBuffer vkProcSymbol = _VkEndCommandBuffer {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkEndCommandBufferUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkEndCommandBufferSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkResetCommandBuffer :: CString pattern VkResetCommandBuffer <- (is_VkResetCommandBuffer -> True) where VkResetCommandBuffer = _VkResetCommandBuffer {-# INLINE _VkResetCommandBuffer #-} _VkResetCommandBuffer :: CString _VkResetCommandBuffer = Ptr "vkResetCommandBuffer\NUL"# {-# INLINE is_VkResetCommandBuffer #-} is_VkResetCommandBuffer :: CString -> Bool is_VkResetCommandBuffer = (EQ ==) . cmpCStrings _VkResetCommandBuffer type VkResetCommandBuffer = "vkResetCommandBuffer" -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkResetCommandBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkCommandBufferResetFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetCommandBuffer vkResetCommandBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myResetCommandBuffer <- vkGetInstanceProc @VkResetCommandBuffer vkInstance -- -- or less efficient: -- -- > myResetCommandBuffer <- vkGetProc @VkResetCommandBuffer -- -- __Note:__ @vkResetCommandBufferUnsafe@ and @vkResetCommandBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkResetCommandBuffer@ is an alias -- of @vkResetCommandBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkResetCommandBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkResetCommandBuffer" vkResetCommandBufferUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkCommandBufferResetFlags -- ^ flags -> IO VkResult #else vkResetCommandBufferUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkCommandBufferResetFlags -- ^ flags -> IO VkResult vkResetCommandBufferUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkResetCommandBuffer) {-# NOINLINE vkResetCommandBufferUnsafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkResetCommandBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkCommandBufferResetFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetCommandBuffer vkResetCommandBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myResetCommandBuffer <- vkGetInstanceProc @VkResetCommandBuffer vkInstance -- -- or less efficient: -- -- > myResetCommandBuffer <- vkGetProc @VkResetCommandBuffer -- -- __Note:__ @vkResetCommandBufferUnsafe@ and @vkResetCommandBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkResetCommandBuffer@ is an alias -- of @vkResetCommandBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkResetCommandBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkResetCommandBuffer" vkResetCommandBufferSafe :: VkCommandBuffer -- ^ commandBuffer -> VkCommandBufferResetFlags -- ^ flags -> IO VkResult #else vkResetCommandBufferSafe :: VkCommandBuffer -- ^ commandBuffer -> VkCommandBufferResetFlags -- ^ flags -> IO VkResult vkResetCommandBufferSafe = unsafeDupablePerformIO (vkGetProcSafe @VkResetCommandBuffer) {-# NOINLINE vkResetCommandBufferSafe #-} #endif -- | -- Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkResetCommandBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkCommandBufferResetFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetCommandBuffer vkResetCommandBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myResetCommandBuffer <- vkGetInstanceProc @VkResetCommandBuffer vkInstance -- -- or less efficient: -- -- > myResetCommandBuffer <- vkGetProc @VkResetCommandBuffer -- -- __Note:__ @vkResetCommandBufferUnsafe@ and @vkResetCommandBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkResetCommandBuffer@ is an alias -- of @vkResetCommandBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkResetCommandBufferSafe@. -- vkResetCommandBuffer :: VkCommandBuffer -- ^ commandBuffer -> VkCommandBufferResetFlags -- ^ flags -> IO VkResult #ifdef UNSAFE_FFI_DEFAULT vkResetCommandBuffer = vkResetCommandBufferUnsafe #else vkResetCommandBuffer = vkResetCommandBufferSafe #endif {-# INLINE vkResetCommandBuffer #-} -- | Success codes: 'VK_SUCCESS'. -- -- Error codes: 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. -- -- > VkResult vkResetCommandBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkCommandBufferResetFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkResetCommandBuffer vkResetCommandBuffer registry at www.khronos.org> type HS_vkResetCommandBuffer = VkCommandBuffer -- ^ commandBuffer -> VkCommandBufferResetFlags -- ^ flags -> IO VkResult type PFN_vkResetCommandBuffer = FunPtr HS_vkResetCommandBuffer foreign import ccall unsafe "dynamic" unwrapVkResetCommandBufferUnsafe :: PFN_vkResetCommandBuffer -> HS_vkResetCommandBuffer foreign import ccall safe "dynamic" unwrapVkResetCommandBufferSafe :: PFN_vkResetCommandBuffer -> HS_vkResetCommandBuffer instance VulkanProc "vkResetCommandBuffer" where type VkProcType "vkResetCommandBuffer" = HS_vkResetCommandBuffer vkProcSymbol = _VkResetCommandBuffer {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkResetCommandBufferUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkResetCommandBufferSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdBindPipeline :: CString pattern VkCmdBindPipeline <- (is_VkCmdBindPipeline -> True) where VkCmdBindPipeline = _VkCmdBindPipeline {-# INLINE _VkCmdBindPipeline #-} _VkCmdBindPipeline :: CString _VkCmdBindPipeline = Ptr "vkCmdBindPipeline\NUL"# {-# INLINE is_VkCmdBindPipeline #-} is_VkCmdBindPipeline :: CString -> Bool is_VkCmdBindPipeline = (EQ ==) . cmpCStrings _VkCmdBindPipeline type VkCmdBindPipeline = "vkCmdBindPipeline" -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdBindPipeline -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineBindPoint pipelineBindPoint -- > , VkPipeline pipeline -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBindPipeline vkCmdBindPipeline registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBindPipeline <- vkGetInstanceProc @VkCmdBindPipeline vkInstance -- -- or less efficient: -- -- > myCmdBindPipeline <- vkGetProc @VkCmdBindPipeline -- -- __Note:__ @vkCmdBindPipelineUnsafe@ and @vkCmdBindPipelineSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBindPipeline@ is an alias -- of @vkCmdBindPipelineUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBindPipelineSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdBindPipeline" vkCmdBindPipelineUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineBindPoint -- ^ pipelineBindPoint -> VkPipeline -- ^ pipeline -> IO () #else vkCmdBindPipelineUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineBindPoint -- ^ pipelineBindPoint -> VkPipeline -- ^ pipeline -> IO () vkCmdBindPipelineUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdBindPipeline) {-# NOINLINE vkCmdBindPipelineUnsafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdBindPipeline -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineBindPoint pipelineBindPoint -- > , VkPipeline pipeline -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBindPipeline vkCmdBindPipeline registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBindPipeline <- vkGetInstanceProc @VkCmdBindPipeline vkInstance -- -- or less efficient: -- -- > myCmdBindPipeline <- vkGetProc @VkCmdBindPipeline -- -- __Note:__ @vkCmdBindPipelineUnsafe@ and @vkCmdBindPipelineSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBindPipeline@ is an alias -- of @vkCmdBindPipelineUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBindPipelineSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdBindPipeline" vkCmdBindPipelineSafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineBindPoint -- ^ pipelineBindPoint -> VkPipeline -- ^ pipeline -> IO () #else vkCmdBindPipelineSafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineBindPoint -- ^ pipelineBindPoint -> VkPipeline -- ^ pipeline -> IO () vkCmdBindPipelineSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdBindPipeline) {-# NOINLINE vkCmdBindPipelineSafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdBindPipeline -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineBindPoint pipelineBindPoint -- > , VkPipeline pipeline -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBindPipeline vkCmdBindPipeline registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBindPipeline <- vkGetInstanceProc @VkCmdBindPipeline vkInstance -- -- or less efficient: -- -- > myCmdBindPipeline <- vkGetProc @VkCmdBindPipeline -- -- __Note:__ @vkCmdBindPipelineUnsafe@ and @vkCmdBindPipelineSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBindPipeline@ is an alias -- of @vkCmdBindPipelineUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBindPipelineSafe@. -- vkCmdBindPipeline :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineBindPoint -- ^ pipelineBindPoint -> VkPipeline -- ^ pipeline -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdBindPipeline = vkCmdBindPipelineUnsafe #else vkCmdBindPipeline = vkCmdBindPipelineSafe #endif {-# INLINE vkCmdBindPipeline #-} -- | Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdBindPipeline -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineBindPoint pipelineBindPoint -- > , VkPipeline pipeline -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBindPipeline vkCmdBindPipeline registry at www.khronos.org> type HS_vkCmdBindPipeline = VkCommandBuffer -- ^ commandBuffer -> VkPipelineBindPoint -- ^ pipelineBindPoint -> VkPipeline -- ^ pipeline -> IO () type PFN_vkCmdBindPipeline = FunPtr HS_vkCmdBindPipeline foreign import ccall unsafe "dynamic" unwrapVkCmdBindPipelineUnsafe :: PFN_vkCmdBindPipeline -> HS_vkCmdBindPipeline foreign import ccall safe "dynamic" unwrapVkCmdBindPipelineSafe :: PFN_vkCmdBindPipeline -> HS_vkCmdBindPipeline instance VulkanProc "vkCmdBindPipeline" where type VkProcType "vkCmdBindPipeline" = HS_vkCmdBindPipeline vkProcSymbol = _VkCmdBindPipeline {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdBindPipelineUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdBindPipelineSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdSetViewport :: CString pattern VkCmdSetViewport <- (is_VkCmdSetViewport -> True) where VkCmdSetViewport = _VkCmdSetViewport {-# INLINE _VkCmdSetViewport #-} _VkCmdSetViewport :: CString _VkCmdSetViewport = Ptr "vkCmdSetViewport\NUL"# {-# INLINE is_VkCmdSetViewport #-} is_VkCmdSetViewport :: CString -> Bool is_VkCmdSetViewport = (EQ ==) . cmpCStrings _VkCmdSetViewport type VkCmdSetViewport = "vkCmdSetViewport" -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetViewport -- > ( VkCommandBuffer commandBuffer -- > , uint32_t firstViewport -- > , uint32_t viewportCount -- > , const VkViewport* pViewports -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetViewport vkCmdSetViewport registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetViewport <- vkGetInstanceProc @VkCmdSetViewport vkInstance -- -- or less efficient: -- -- > myCmdSetViewport <- vkGetProc @VkCmdSetViewport -- -- __Note:__ @vkCmdSetViewportUnsafe@ and @vkCmdSetViewportSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetViewport@ is an alias -- of @vkCmdSetViewportUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetViewportSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdSetViewport" vkCmdSetViewportUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ firstViewport -> Word32 -- ^ viewportCount -> Ptr VkViewport -- ^ pViewports -> IO () #else vkCmdSetViewportUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ firstViewport -> Word32 -- ^ viewportCount -> Ptr VkViewport -- ^ pViewports -> IO () vkCmdSetViewportUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdSetViewport) {-# NOINLINE vkCmdSetViewportUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetViewport -- > ( VkCommandBuffer commandBuffer -- > , uint32_t firstViewport -- > , uint32_t viewportCount -- > , const VkViewport* pViewports -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetViewport vkCmdSetViewport registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetViewport <- vkGetInstanceProc @VkCmdSetViewport vkInstance -- -- or less efficient: -- -- > myCmdSetViewport <- vkGetProc @VkCmdSetViewport -- -- __Note:__ @vkCmdSetViewportUnsafe@ and @vkCmdSetViewportSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetViewport@ is an alias -- of @vkCmdSetViewportUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetViewportSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdSetViewport" vkCmdSetViewportSafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ firstViewport -> Word32 -- ^ viewportCount -> Ptr VkViewport -- ^ pViewports -> IO () #else vkCmdSetViewportSafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ firstViewport -> Word32 -- ^ viewportCount -> Ptr VkViewport -- ^ pViewports -> IO () vkCmdSetViewportSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdSetViewport) {-# NOINLINE vkCmdSetViewportSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetViewport -- > ( VkCommandBuffer commandBuffer -- > , uint32_t firstViewport -- > , uint32_t viewportCount -- > , const VkViewport* pViewports -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetViewport vkCmdSetViewport registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetViewport <- vkGetInstanceProc @VkCmdSetViewport vkInstance -- -- or less efficient: -- -- > myCmdSetViewport <- vkGetProc @VkCmdSetViewport -- -- __Note:__ @vkCmdSetViewportUnsafe@ and @vkCmdSetViewportSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetViewport@ is an alias -- of @vkCmdSetViewportUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetViewportSafe@. -- vkCmdSetViewport :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ firstViewport -> Word32 -- ^ viewportCount -> Ptr VkViewport -- ^ pViewports -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdSetViewport = vkCmdSetViewportUnsafe #else vkCmdSetViewport = vkCmdSetViewportSafe #endif {-# INLINE vkCmdSetViewport #-} -- | Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetViewport -- > ( VkCommandBuffer commandBuffer -- > , uint32_t firstViewport -- > , uint32_t viewportCount -- > , const VkViewport* pViewports -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetViewport vkCmdSetViewport registry at www.khronos.org> type HS_vkCmdSetViewport = VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ firstViewport -> Word32 -- ^ viewportCount -> Ptr VkViewport -- ^ pViewports -> IO () type PFN_vkCmdSetViewport = FunPtr HS_vkCmdSetViewport foreign import ccall unsafe "dynamic" unwrapVkCmdSetViewportUnsafe :: PFN_vkCmdSetViewport -> HS_vkCmdSetViewport foreign import ccall safe "dynamic" unwrapVkCmdSetViewportSafe :: PFN_vkCmdSetViewport -> HS_vkCmdSetViewport instance VulkanProc "vkCmdSetViewport" where type VkProcType "vkCmdSetViewport" = HS_vkCmdSetViewport vkProcSymbol = _VkCmdSetViewport {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdSetViewportUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdSetViewportSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdSetScissor :: CString pattern VkCmdSetScissor <- (is_VkCmdSetScissor -> True) where VkCmdSetScissor = _VkCmdSetScissor {-# INLINE _VkCmdSetScissor #-} _VkCmdSetScissor :: CString _VkCmdSetScissor = Ptr "vkCmdSetScissor\NUL"# {-# INLINE is_VkCmdSetScissor #-} is_VkCmdSetScissor :: CString -> Bool is_VkCmdSetScissor = (EQ ==) . cmpCStrings _VkCmdSetScissor type VkCmdSetScissor = "vkCmdSetScissor" -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetScissor -- > ( VkCommandBuffer commandBuffer -- > , uint32_t firstScissor -- > , uint32_t scissorCount -- > , const VkRect2D* pScissors -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetScissor vkCmdSetScissor registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetScissor <- vkGetInstanceProc @VkCmdSetScissor vkInstance -- -- or less efficient: -- -- > myCmdSetScissor <- vkGetProc @VkCmdSetScissor -- -- __Note:__ @vkCmdSetScissorUnsafe@ and @vkCmdSetScissorSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetScissor@ is an alias -- of @vkCmdSetScissorUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetScissorSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdSetScissor" vkCmdSetScissorUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ firstScissor -> Word32 -- ^ scissorCount -> Ptr VkRect2D -- ^ pScissors -> IO () #else vkCmdSetScissorUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ firstScissor -> Word32 -- ^ scissorCount -> Ptr VkRect2D -- ^ pScissors -> IO () vkCmdSetScissorUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdSetScissor) {-# NOINLINE vkCmdSetScissorUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetScissor -- > ( VkCommandBuffer commandBuffer -- > , uint32_t firstScissor -- > , uint32_t scissorCount -- > , const VkRect2D* pScissors -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetScissor vkCmdSetScissor registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetScissor <- vkGetInstanceProc @VkCmdSetScissor vkInstance -- -- or less efficient: -- -- > myCmdSetScissor <- vkGetProc @VkCmdSetScissor -- -- __Note:__ @vkCmdSetScissorUnsafe@ and @vkCmdSetScissorSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetScissor@ is an alias -- of @vkCmdSetScissorUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetScissorSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdSetScissor" vkCmdSetScissorSafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ firstScissor -> Word32 -- ^ scissorCount -> Ptr VkRect2D -- ^ pScissors -> IO () #else vkCmdSetScissorSafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ firstScissor -> Word32 -- ^ scissorCount -> Ptr VkRect2D -- ^ pScissors -> IO () vkCmdSetScissorSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdSetScissor) {-# NOINLINE vkCmdSetScissorSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetScissor -- > ( VkCommandBuffer commandBuffer -- > , uint32_t firstScissor -- > , uint32_t scissorCount -- > , const VkRect2D* pScissors -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetScissor vkCmdSetScissor registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetScissor <- vkGetInstanceProc @VkCmdSetScissor vkInstance -- -- or less efficient: -- -- > myCmdSetScissor <- vkGetProc @VkCmdSetScissor -- -- __Note:__ @vkCmdSetScissorUnsafe@ and @vkCmdSetScissorSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetScissor@ is an alias -- of @vkCmdSetScissorUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetScissorSafe@. -- vkCmdSetScissor :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ firstScissor -> Word32 -- ^ scissorCount -> Ptr VkRect2D -- ^ pScissors -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdSetScissor = vkCmdSetScissorUnsafe #else vkCmdSetScissor = vkCmdSetScissorSafe #endif {-# INLINE vkCmdSetScissor #-} -- | Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetScissor -- > ( VkCommandBuffer commandBuffer -- > , uint32_t firstScissor -- > , uint32_t scissorCount -- > , const VkRect2D* pScissors -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetScissor vkCmdSetScissor registry at www.khronos.org> type HS_vkCmdSetScissor = VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ firstScissor -> Word32 -- ^ scissorCount -> Ptr VkRect2D -- ^ pScissors -> IO () type PFN_vkCmdSetScissor = FunPtr HS_vkCmdSetScissor foreign import ccall unsafe "dynamic" unwrapVkCmdSetScissorUnsafe :: PFN_vkCmdSetScissor -> HS_vkCmdSetScissor foreign import ccall safe "dynamic" unwrapVkCmdSetScissorSafe :: PFN_vkCmdSetScissor -> HS_vkCmdSetScissor instance VulkanProc "vkCmdSetScissor" where type VkProcType "vkCmdSetScissor" = HS_vkCmdSetScissor vkProcSymbol = _VkCmdSetScissor {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdSetScissorUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdSetScissorSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdSetLineWidth :: CString pattern VkCmdSetLineWidth <- (is_VkCmdSetLineWidth -> True) where VkCmdSetLineWidth = _VkCmdSetLineWidth {-# INLINE _VkCmdSetLineWidth #-} _VkCmdSetLineWidth :: CString _VkCmdSetLineWidth = Ptr "vkCmdSetLineWidth\NUL"# {-# INLINE is_VkCmdSetLineWidth #-} is_VkCmdSetLineWidth :: CString -> Bool is_VkCmdSetLineWidth = (EQ ==) . cmpCStrings _VkCmdSetLineWidth type VkCmdSetLineWidth = "vkCmdSetLineWidth" -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetLineWidth -- > ( VkCommandBuffer commandBuffer -- > , float lineWidth -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetLineWidth vkCmdSetLineWidth registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetLineWidth <- vkGetInstanceProc @VkCmdSetLineWidth vkInstance -- -- or less efficient: -- -- > myCmdSetLineWidth <- vkGetProc @VkCmdSetLineWidth -- -- __Note:__ @vkCmdSetLineWidthUnsafe@ and @vkCmdSetLineWidthSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetLineWidth@ is an alias -- of @vkCmdSetLineWidthUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetLineWidthSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdSetLineWidth" vkCmdSetLineWidthUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Float -> IO () {-# LINE 21086 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} #else vkCmdSetLineWidthUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Float -> IO () {-# LINE 21091 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} vkCmdSetLineWidthUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdSetLineWidth) {-# NOINLINE vkCmdSetLineWidthUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetLineWidth -- > ( VkCommandBuffer commandBuffer -- > , float lineWidth -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetLineWidth vkCmdSetLineWidth registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetLineWidth <- vkGetInstanceProc @VkCmdSetLineWidth vkInstance -- -- or less efficient: -- -- > myCmdSetLineWidth <- vkGetProc @VkCmdSetLineWidth -- -- __Note:__ @vkCmdSetLineWidthUnsafe@ and @vkCmdSetLineWidthSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetLineWidth@ is an alias -- of @vkCmdSetLineWidthUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetLineWidthSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdSetLineWidth" vkCmdSetLineWidthSafe :: VkCommandBuffer -- ^ commandBuffer -> Float -> IO () {-# LINE 21131 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} #else vkCmdSetLineWidthSafe :: VkCommandBuffer -- ^ commandBuffer -> Float -> IO () {-# LINE 21136 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} vkCmdSetLineWidthSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdSetLineWidth) {-# NOINLINE vkCmdSetLineWidthSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetLineWidth -- > ( VkCommandBuffer commandBuffer -- > , float lineWidth -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetLineWidth vkCmdSetLineWidth registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetLineWidth <- vkGetInstanceProc @VkCmdSetLineWidth vkInstance -- -- or less efficient: -- -- > myCmdSetLineWidth <- vkGetProc @VkCmdSetLineWidth -- -- __Note:__ @vkCmdSetLineWidthUnsafe@ and @vkCmdSetLineWidthSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetLineWidth@ is an alias -- of @vkCmdSetLineWidthUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetLineWidthSafe@. -- vkCmdSetLineWidth :: VkCommandBuffer -- ^ commandBuffer -> Float -> IO () {-# LINE 21174 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} #ifdef UNSAFE_FFI_DEFAULT vkCmdSetLineWidth = vkCmdSetLineWidthUnsafe #else vkCmdSetLineWidth = vkCmdSetLineWidthSafe #endif {-# INLINE vkCmdSetLineWidth #-} -- | Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetLineWidth -- > ( VkCommandBuffer commandBuffer -- > , float lineWidth -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetLineWidth vkCmdSetLineWidth registry at www.khronos.org> type HS_vkCmdSetLineWidth = VkCommandBuffer -- ^ commandBuffer -> Float -> IO () {-# LINE 21195 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} type PFN_vkCmdSetLineWidth = FunPtr HS_vkCmdSetLineWidth foreign import ccall unsafe "dynamic" unwrapVkCmdSetLineWidthUnsafe :: PFN_vkCmdSetLineWidth -> HS_vkCmdSetLineWidth foreign import ccall safe "dynamic" unwrapVkCmdSetLineWidthSafe :: PFN_vkCmdSetLineWidth -> HS_vkCmdSetLineWidth instance VulkanProc "vkCmdSetLineWidth" where type VkProcType "vkCmdSetLineWidth" = HS_vkCmdSetLineWidth vkProcSymbol = _VkCmdSetLineWidth {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdSetLineWidthUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdSetLineWidthSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdSetDepthBias :: CString pattern VkCmdSetDepthBias <- (is_VkCmdSetDepthBias -> True) where VkCmdSetDepthBias = _VkCmdSetDepthBias {-# INLINE _VkCmdSetDepthBias #-} _VkCmdSetDepthBias :: CString _VkCmdSetDepthBias = Ptr "vkCmdSetDepthBias\NUL"# {-# INLINE is_VkCmdSetDepthBias #-} is_VkCmdSetDepthBias :: CString -> Bool is_VkCmdSetDepthBias = (EQ ==) . cmpCStrings _VkCmdSetDepthBias type VkCmdSetDepthBias = "vkCmdSetDepthBias" -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetDepthBias -- > ( VkCommandBuffer commandBuffer -- > , float depthBiasConstantFactor -- > , float depthBiasClamp -- > , float depthBiasSlopeFactor -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetDepthBias vkCmdSetDepthBias registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetDepthBias <- vkGetInstanceProc @VkCmdSetDepthBias vkInstance -- -- or less efficient: -- -- > myCmdSetDepthBias <- vkGetProc @VkCmdSetDepthBias -- -- __Note:__ @vkCmdSetDepthBiasUnsafe@ and @vkCmdSetDepthBiasSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetDepthBias@ is an alias -- of @vkCmdSetDepthBiasUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetDepthBiasSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdSetDepthBias" vkCmdSetDepthBiasUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Float -> {-# LINE 21272 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} Float -> Float -> IO () {-# LINE 21273 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} #else vkCmdSetDepthBiasUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Float -> {-# LINE 21279 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} Float -> Float -> IO () {-# LINE 21280 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} vkCmdSetDepthBiasUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdSetDepthBias) {-# NOINLINE vkCmdSetDepthBiasUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetDepthBias -- > ( VkCommandBuffer commandBuffer -- > , float depthBiasConstantFactor -- > , float depthBiasClamp -- > , float depthBiasSlopeFactor -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetDepthBias vkCmdSetDepthBias registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetDepthBias <- vkGetInstanceProc @VkCmdSetDepthBias vkInstance -- -- or less efficient: -- -- > myCmdSetDepthBias <- vkGetProc @VkCmdSetDepthBias -- -- __Note:__ @vkCmdSetDepthBiasUnsafe@ and @vkCmdSetDepthBiasSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetDepthBias@ is an alias -- of @vkCmdSetDepthBiasUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetDepthBiasSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdSetDepthBias" vkCmdSetDepthBiasSafe :: VkCommandBuffer -- ^ commandBuffer -> Float -> {-# LINE 21324 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} Float -> Float -> IO () {-# LINE 21325 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} #else vkCmdSetDepthBiasSafe :: VkCommandBuffer -- ^ commandBuffer -> Float -> {-# LINE 21331 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} Float -> Float -> IO () {-# LINE 21332 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} vkCmdSetDepthBiasSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdSetDepthBias) {-# NOINLINE vkCmdSetDepthBiasSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetDepthBias -- > ( VkCommandBuffer commandBuffer -- > , float depthBiasConstantFactor -- > , float depthBiasClamp -- > , float depthBiasSlopeFactor -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetDepthBias vkCmdSetDepthBias registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetDepthBias <- vkGetInstanceProc @VkCmdSetDepthBias vkInstance -- -- or less efficient: -- -- > myCmdSetDepthBias <- vkGetProc @VkCmdSetDepthBias -- -- __Note:__ @vkCmdSetDepthBiasUnsafe@ and @vkCmdSetDepthBiasSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetDepthBias@ is an alias -- of @vkCmdSetDepthBiasUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetDepthBiasSafe@. -- vkCmdSetDepthBias :: VkCommandBuffer -- ^ commandBuffer -> Float -> {-# LINE 21373 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} Float -> Float -> IO () {-# LINE 21374 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} #ifdef UNSAFE_FFI_DEFAULT vkCmdSetDepthBias = vkCmdSetDepthBiasUnsafe #else vkCmdSetDepthBias = vkCmdSetDepthBiasSafe #endif {-# INLINE vkCmdSetDepthBias #-} -- | Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetDepthBias -- > ( VkCommandBuffer commandBuffer -- > , float depthBiasConstantFactor -- > , float depthBiasClamp -- > , float depthBiasSlopeFactor -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetDepthBias vkCmdSetDepthBias registry at www.khronos.org> type HS_vkCmdSetDepthBias = VkCommandBuffer -- ^ commandBuffer -> Float -> {-# LINE 21398 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} Float -> Float -> IO () {-# LINE 21399 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} type PFN_vkCmdSetDepthBias = FunPtr HS_vkCmdSetDepthBias foreign import ccall unsafe "dynamic" unwrapVkCmdSetDepthBiasUnsafe :: PFN_vkCmdSetDepthBias -> HS_vkCmdSetDepthBias foreign import ccall safe "dynamic" unwrapVkCmdSetDepthBiasSafe :: PFN_vkCmdSetDepthBias -> HS_vkCmdSetDepthBias instance VulkanProc "vkCmdSetDepthBias" where type VkProcType "vkCmdSetDepthBias" = HS_vkCmdSetDepthBias vkProcSymbol = _VkCmdSetDepthBias {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdSetDepthBiasUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdSetDepthBiasSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdSetBlendConstants :: CString pattern VkCmdSetBlendConstants <- (is_VkCmdSetBlendConstants -> True) where VkCmdSetBlendConstants = _VkCmdSetBlendConstants {-# INLINE _VkCmdSetBlendConstants #-} _VkCmdSetBlendConstants :: CString _VkCmdSetBlendConstants = Ptr "vkCmdSetBlendConstants\NUL"# {-# INLINE is_VkCmdSetBlendConstants #-} is_VkCmdSetBlendConstants :: CString -> Bool is_VkCmdSetBlendConstants = (EQ ==) . cmpCStrings _VkCmdSetBlendConstants type VkCmdSetBlendConstants = "vkCmdSetBlendConstants" -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetBlendConstants -- > ( VkCommandBuffer commandBuffer -- > , const float blendConstants[4] -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetBlendConstants vkCmdSetBlendConstants registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetBlendConstants <- vkGetInstanceProc @VkCmdSetBlendConstants vkInstance -- -- or less efficient: -- -- > myCmdSetBlendConstants <- vkGetProc @VkCmdSetBlendConstants -- -- __Note:__ @vkCmdSetBlendConstantsUnsafe@ and @vkCmdSetBlendConstantsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetBlendConstants@ is an alias -- of @vkCmdSetBlendConstantsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetBlendConstantsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdSetBlendConstants" vkCmdSetBlendConstantsUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Ptr Float -- ^ blendConstants {-# LINE 21475 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} -> IO () #else vkCmdSetBlendConstantsUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Ptr Float -- ^ blendConstants {-# LINE 21481 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} -> IO () vkCmdSetBlendConstantsUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdSetBlendConstants) {-# NOINLINE vkCmdSetBlendConstantsUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetBlendConstants -- > ( VkCommandBuffer commandBuffer -- > , const float blendConstants[4] -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetBlendConstants vkCmdSetBlendConstants registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetBlendConstants <- vkGetInstanceProc @VkCmdSetBlendConstants vkInstance -- -- or less efficient: -- -- > myCmdSetBlendConstants <- vkGetProc @VkCmdSetBlendConstants -- -- __Note:__ @vkCmdSetBlendConstantsUnsafe@ and @vkCmdSetBlendConstantsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetBlendConstants@ is an alias -- of @vkCmdSetBlendConstantsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetBlendConstantsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdSetBlendConstants" vkCmdSetBlendConstantsSafe :: VkCommandBuffer -- ^ commandBuffer -> Ptr Float -- ^ blendConstants {-# LINE 21523 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} -> IO () #else vkCmdSetBlendConstantsSafe :: VkCommandBuffer -- ^ commandBuffer -> Ptr Float -- ^ blendConstants {-# LINE 21529 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} -> IO () vkCmdSetBlendConstantsSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdSetBlendConstants) {-# NOINLINE vkCmdSetBlendConstantsSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetBlendConstants -- > ( VkCommandBuffer commandBuffer -- > , const float blendConstants[4] -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetBlendConstants vkCmdSetBlendConstants registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetBlendConstants <- vkGetInstanceProc @VkCmdSetBlendConstants vkInstance -- -- or less efficient: -- -- > myCmdSetBlendConstants <- vkGetProc @VkCmdSetBlendConstants -- -- __Note:__ @vkCmdSetBlendConstantsUnsafe@ and @vkCmdSetBlendConstantsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetBlendConstants@ is an alias -- of @vkCmdSetBlendConstantsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetBlendConstantsSafe@. -- vkCmdSetBlendConstants :: VkCommandBuffer -- ^ commandBuffer -> Ptr Float -- ^ blendConstants {-# LINE 21568 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdSetBlendConstants = vkCmdSetBlendConstantsUnsafe #else vkCmdSetBlendConstants = vkCmdSetBlendConstantsSafe #endif {-# INLINE vkCmdSetBlendConstants #-} -- | Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetBlendConstants -- > ( VkCommandBuffer commandBuffer -- > , const float blendConstants[4] -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetBlendConstants vkCmdSetBlendConstants registry at www.khronos.org> type HS_vkCmdSetBlendConstants = VkCommandBuffer -- ^ commandBuffer -> Ptr Float -- ^ blendConstants {-# LINE 21590 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} -> IO () type PFN_vkCmdSetBlendConstants = FunPtr HS_vkCmdSetBlendConstants foreign import ccall unsafe "dynamic" unwrapVkCmdSetBlendConstantsUnsafe :: PFN_vkCmdSetBlendConstants -> HS_vkCmdSetBlendConstants foreign import ccall safe "dynamic" unwrapVkCmdSetBlendConstantsSafe :: PFN_vkCmdSetBlendConstants -> HS_vkCmdSetBlendConstants instance VulkanProc "vkCmdSetBlendConstants" where type VkProcType "vkCmdSetBlendConstants" = HS_vkCmdSetBlendConstants vkProcSymbol = _VkCmdSetBlendConstants {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdSetBlendConstantsUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdSetBlendConstantsSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdSetDepthBounds :: CString pattern VkCmdSetDepthBounds <- (is_VkCmdSetDepthBounds -> True) where VkCmdSetDepthBounds = _VkCmdSetDepthBounds {-# INLINE _VkCmdSetDepthBounds #-} _VkCmdSetDepthBounds :: CString _VkCmdSetDepthBounds = Ptr "vkCmdSetDepthBounds\NUL"# {-# INLINE is_VkCmdSetDepthBounds #-} is_VkCmdSetDepthBounds :: CString -> Bool is_VkCmdSetDepthBounds = (EQ ==) . cmpCStrings _VkCmdSetDepthBounds type VkCmdSetDepthBounds = "vkCmdSetDepthBounds" -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetDepthBounds -- > ( VkCommandBuffer commandBuffer -- > , float minDepthBounds -- > , float maxDepthBounds -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetDepthBounds vkCmdSetDepthBounds registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetDepthBounds <- vkGetInstanceProc @VkCmdSetDepthBounds vkInstance -- -- or less efficient: -- -- > myCmdSetDepthBounds <- vkGetProc @VkCmdSetDepthBounds -- -- __Note:__ @vkCmdSetDepthBoundsUnsafe@ and @vkCmdSetDepthBoundsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetDepthBounds@ is an alias -- of @vkCmdSetDepthBoundsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetDepthBoundsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdSetDepthBounds" vkCmdSetDepthBoundsUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Float -> Float -> IO () {-# LINE 21670 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} #else vkCmdSetDepthBoundsUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Float -> Float -> IO () {-# LINE 21676 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} vkCmdSetDepthBoundsUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdSetDepthBounds) {-# NOINLINE vkCmdSetDepthBoundsUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetDepthBounds -- > ( VkCommandBuffer commandBuffer -- > , float minDepthBounds -- > , float maxDepthBounds -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetDepthBounds vkCmdSetDepthBounds registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetDepthBounds <- vkGetInstanceProc @VkCmdSetDepthBounds vkInstance -- -- or less efficient: -- -- > myCmdSetDepthBounds <- vkGetProc @VkCmdSetDepthBounds -- -- __Note:__ @vkCmdSetDepthBoundsUnsafe@ and @vkCmdSetDepthBoundsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetDepthBounds@ is an alias -- of @vkCmdSetDepthBoundsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetDepthBoundsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdSetDepthBounds" vkCmdSetDepthBoundsSafe :: VkCommandBuffer -- ^ commandBuffer -> Float -> Float -> IO () {-# LINE 21719 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} #else vkCmdSetDepthBoundsSafe :: VkCommandBuffer -- ^ commandBuffer -> Float -> Float -> IO () {-# LINE 21725 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} vkCmdSetDepthBoundsSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdSetDepthBounds) {-# NOINLINE vkCmdSetDepthBoundsSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetDepthBounds -- > ( VkCommandBuffer commandBuffer -- > , float minDepthBounds -- > , float maxDepthBounds -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetDepthBounds vkCmdSetDepthBounds registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetDepthBounds <- vkGetInstanceProc @VkCmdSetDepthBounds vkInstance -- -- or less efficient: -- -- > myCmdSetDepthBounds <- vkGetProc @VkCmdSetDepthBounds -- -- __Note:__ @vkCmdSetDepthBoundsUnsafe@ and @vkCmdSetDepthBoundsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetDepthBounds@ is an alias -- of @vkCmdSetDepthBoundsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetDepthBoundsSafe@. -- vkCmdSetDepthBounds :: VkCommandBuffer -- ^ commandBuffer -> Float -> Float -> IO () {-# LINE 21765 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} #ifdef UNSAFE_FFI_DEFAULT vkCmdSetDepthBounds = vkCmdSetDepthBoundsUnsafe #else vkCmdSetDepthBounds = vkCmdSetDepthBoundsSafe #endif {-# INLINE vkCmdSetDepthBounds #-} -- | Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetDepthBounds -- > ( VkCommandBuffer commandBuffer -- > , float minDepthBounds -- > , float maxDepthBounds -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetDepthBounds vkCmdSetDepthBounds registry at www.khronos.org> type HS_vkCmdSetDepthBounds = VkCommandBuffer -- ^ commandBuffer -> Float -> Float -> IO () {-# LINE 21788 "src-gen/Graphics/Vulkan/Core_1_0.hsc" #-} type PFN_vkCmdSetDepthBounds = FunPtr HS_vkCmdSetDepthBounds foreign import ccall unsafe "dynamic" unwrapVkCmdSetDepthBoundsUnsafe :: PFN_vkCmdSetDepthBounds -> HS_vkCmdSetDepthBounds foreign import ccall safe "dynamic" unwrapVkCmdSetDepthBoundsSafe :: PFN_vkCmdSetDepthBounds -> HS_vkCmdSetDepthBounds instance VulkanProc "vkCmdSetDepthBounds" where type VkProcType "vkCmdSetDepthBounds" = HS_vkCmdSetDepthBounds vkProcSymbol = _VkCmdSetDepthBounds {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdSetDepthBoundsUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdSetDepthBoundsSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdSetStencilCompareMask :: CString pattern VkCmdSetStencilCompareMask <- (is_VkCmdSetStencilCompareMask -> True) where VkCmdSetStencilCompareMask = _VkCmdSetStencilCompareMask {-# INLINE _VkCmdSetStencilCompareMask #-} _VkCmdSetStencilCompareMask :: CString _VkCmdSetStencilCompareMask = Ptr "vkCmdSetStencilCompareMask\NUL"# {-# INLINE is_VkCmdSetStencilCompareMask #-} is_VkCmdSetStencilCompareMask :: CString -> Bool is_VkCmdSetStencilCompareMask = (EQ ==) . cmpCStrings _VkCmdSetStencilCompareMask type VkCmdSetStencilCompareMask = "vkCmdSetStencilCompareMask" -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetStencilCompareMask -- > ( VkCommandBuffer commandBuffer -- > , VkStencilFaceFlags faceMask -- > , uint32_t compareMask -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetStencilCompareMask <- vkGetInstanceProc @VkCmdSetStencilCompareMask vkInstance -- -- or less efficient: -- -- > myCmdSetStencilCompareMask <- vkGetProc @VkCmdSetStencilCompareMask -- -- __Note:__ @vkCmdSetStencilCompareMaskUnsafe@ and @vkCmdSetStencilCompareMaskSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetStencilCompareMask@ is an alias -- of @vkCmdSetStencilCompareMaskUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetStencilCompareMaskSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdSetStencilCompareMask" vkCmdSetStencilCompareMaskUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkStencilFaceFlags -- ^ faceMask -> Word32 -- ^ compareMask -> IO () #else vkCmdSetStencilCompareMaskUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkStencilFaceFlags -- ^ faceMask -> Word32 -- ^ compareMask -> IO () vkCmdSetStencilCompareMaskUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdSetStencilCompareMask) {-# NOINLINE vkCmdSetStencilCompareMaskUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetStencilCompareMask -- > ( VkCommandBuffer commandBuffer -- > , VkStencilFaceFlags faceMask -- > , uint32_t compareMask -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetStencilCompareMask <- vkGetInstanceProc @VkCmdSetStencilCompareMask vkInstance -- -- or less efficient: -- -- > myCmdSetStencilCompareMask <- vkGetProc @VkCmdSetStencilCompareMask -- -- __Note:__ @vkCmdSetStencilCompareMaskUnsafe@ and @vkCmdSetStencilCompareMaskSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetStencilCompareMask@ is an alias -- of @vkCmdSetStencilCompareMaskUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetStencilCompareMaskSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdSetStencilCompareMask" vkCmdSetStencilCompareMaskSafe :: VkCommandBuffer -- ^ commandBuffer -> VkStencilFaceFlags -- ^ faceMask -> Word32 -- ^ compareMask -> IO () #else vkCmdSetStencilCompareMaskSafe :: VkCommandBuffer -- ^ commandBuffer -> VkStencilFaceFlags -- ^ faceMask -> Word32 -- ^ compareMask -> IO () vkCmdSetStencilCompareMaskSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdSetStencilCompareMask) {-# NOINLINE vkCmdSetStencilCompareMaskSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetStencilCompareMask -- > ( VkCommandBuffer commandBuffer -- > , VkStencilFaceFlags faceMask -- > , uint32_t compareMask -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetStencilCompareMask <- vkGetInstanceProc @VkCmdSetStencilCompareMask vkInstance -- -- or less efficient: -- -- > myCmdSetStencilCompareMask <- vkGetProc @VkCmdSetStencilCompareMask -- -- __Note:__ @vkCmdSetStencilCompareMaskUnsafe@ and @vkCmdSetStencilCompareMaskSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetStencilCompareMask@ is an alias -- of @vkCmdSetStencilCompareMaskUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetStencilCompareMaskSafe@. -- vkCmdSetStencilCompareMask :: VkCommandBuffer -- ^ commandBuffer -> VkStencilFaceFlags -- ^ faceMask -> Word32 -- ^ compareMask -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdSetStencilCompareMask = vkCmdSetStencilCompareMaskUnsafe #else vkCmdSetStencilCompareMask = vkCmdSetStencilCompareMaskSafe #endif {-# INLINE vkCmdSetStencilCompareMask #-} -- | Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetStencilCompareMask -- > ( VkCommandBuffer commandBuffer -- > , VkStencilFaceFlags faceMask -- > , uint32_t compareMask -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask registry at www.khronos.org> type HS_vkCmdSetStencilCompareMask = VkCommandBuffer -- ^ commandBuffer -> VkStencilFaceFlags -- ^ faceMask -> Word32 -- ^ compareMask -> IO () type PFN_vkCmdSetStencilCompareMask = FunPtr HS_vkCmdSetStencilCompareMask foreign import ccall unsafe "dynamic" unwrapVkCmdSetStencilCompareMaskUnsafe :: PFN_vkCmdSetStencilCompareMask -> HS_vkCmdSetStencilCompareMask foreign import ccall safe "dynamic" unwrapVkCmdSetStencilCompareMaskSafe :: PFN_vkCmdSetStencilCompareMask -> HS_vkCmdSetStencilCompareMask instance VulkanProc "vkCmdSetStencilCompareMask" where type VkProcType "vkCmdSetStencilCompareMask" = HS_vkCmdSetStencilCompareMask vkProcSymbol = _VkCmdSetStencilCompareMask {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdSetStencilCompareMaskUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdSetStencilCompareMaskSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdSetStencilWriteMask :: CString pattern VkCmdSetStencilWriteMask <- (is_VkCmdSetStencilWriteMask -> True) where VkCmdSetStencilWriteMask = _VkCmdSetStencilWriteMask {-# INLINE _VkCmdSetStencilWriteMask #-} _VkCmdSetStencilWriteMask :: CString _VkCmdSetStencilWriteMask = Ptr "vkCmdSetStencilWriteMask\NUL"# {-# INLINE is_VkCmdSetStencilWriteMask #-} is_VkCmdSetStencilWriteMask :: CString -> Bool is_VkCmdSetStencilWriteMask = (EQ ==) . cmpCStrings _VkCmdSetStencilWriteMask type VkCmdSetStencilWriteMask = "vkCmdSetStencilWriteMask" -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetStencilWriteMask -- > ( VkCommandBuffer commandBuffer -- > , VkStencilFaceFlags faceMask -- > , uint32_t writeMask -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetStencilWriteMask <- vkGetInstanceProc @VkCmdSetStencilWriteMask vkInstance -- -- or less efficient: -- -- > myCmdSetStencilWriteMask <- vkGetProc @VkCmdSetStencilWriteMask -- -- __Note:__ @vkCmdSetStencilWriteMaskUnsafe@ and @vkCmdSetStencilWriteMaskSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetStencilWriteMask@ is an alias -- of @vkCmdSetStencilWriteMaskUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetStencilWriteMaskSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdSetStencilWriteMask" vkCmdSetStencilWriteMaskUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkStencilFaceFlags -- ^ faceMask -> Word32 -- ^ writeMask -> IO () #else vkCmdSetStencilWriteMaskUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkStencilFaceFlags -- ^ faceMask -> Word32 -- ^ writeMask -> IO () vkCmdSetStencilWriteMaskUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdSetStencilWriteMask) {-# NOINLINE vkCmdSetStencilWriteMaskUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetStencilWriteMask -- > ( VkCommandBuffer commandBuffer -- > , VkStencilFaceFlags faceMask -- > , uint32_t writeMask -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetStencilWriteMask <- vkGetInstanceProc @VkCmdSetStencilWriteMask vkInstance -- -- or less efficient: -- -- > myCmdSetStencilWriteMask <- vkGetProc @VkCmdSetStencilWriteMask -- -- __Note:__ @vkCmdSetStencilWriteMaskUnsafe@ and @vkCmdSetStencilWriteMaskSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetStencilWriteMask@ is an alias -- of @vkCmdSetStencilWriteMaskUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetStencilWriteMaskSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdSetStencilWriteMask" vkCmdSetStencilWriteMaskSafe :: VkCommandBuffer -- ^ commandBuffer -> VkStencilFaceFlags -- ^ faceMask -> Word32 -- ^ writeMask -> IO () #else vkCmdSetStencilWriteMaskSafe :: VkCommandBuffer -- ^ commandBuffer -> VkStencilFaceFlags -- ^ faceMask -> Word32 -- ^ writeMask -> IO () vkCmdSetStencilWriteMaskSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdSetStencilWriteMask) {-# NOINLINE vkCmdSetStencilWriteMaskSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetStencilWriteMask -- > ( VkCommandBuffer commandBuffer -- > , VkStencilFaceFlags faceMask -- > , uint32_t writeMask -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetStencilWriteMask <- vkGetInstanceProc @VkCmdSetStencilWriteMask vkInstance -- -- or less efficient: -- -- > myCmdSetStencilWriteMask <- vkGetProc @VkCmdSetStencilWriteMask -- -- __Note:__ @vkCmdSetStencilWriteMaskUnsafe@ and @vkCmdSetStencilWriteMaskSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetStencilWriteMask@ is an alias -- of @vkCmdSetStencilWriteMaskUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetStencilWriteMaskSafe@. -- vkCmdSetStencilWriteMask :: VkCommandBuffer -- ^ commandBuffer -> VkStencilFaceFlags -- ^ faceMask -> Word32 -- ^ writeMask -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdSetStencilWriteMask = vkCmdSetStencilWriteMaskUnsafe #else vkCmdSetStencilWriteMask = vkCmdSetStencilWriteMaskSafe #endif {-# INLINE vkCmdSetStencilWriteMask #-} -- | Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetStencilWriteMask -- > ( VkCommandBuffer commandBuffer -- > , VkStencilFaceFlags faceMask -- > , uint32_t writeMask -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask registry at www.khronos.org> type HS_vkCmdSetStencilWriteMask = VkCommandBuffer -- ^ commandBuffer -> VkStencilFaceFlags -- ^ faceMask -> Word32 -- ^ writeMask -> IO () type PFN_vkCmdSetStencilWriteMask = FunPtr HS_vkCmdSetStencilWriteMask foreign import ccall unsafe "dynamic" unwrapVkCmdSetStencilWriteMaskUnsafe :: PFN_vkCmdSetStencilWriteMask -> HS_vkCmdSetStencilWriteMask foreign import ccall safe "dynamic" unwrapVkCmdSetStencilWriteMaskSafe :: PFN_vkCmdSetStencilWriteMask -> HS_vkCmdSetStencilWriteMask instance VulkanProc "vkCmdSetStencilWriteMask" where type VkProcType "vkCmdSetStencilWriteMask" = HS_vkCmdSetStencilWriteMask vkProcSymbol = _VkCmdSetStencilWriteMask {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdSetStencilWriteMaskUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdSetStencilWriteMaskSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdSetStencilReference :: CString pattern VkCmdSetStencilReference <- (is_VkCmdSetStencilReference -> True) where VkCmdSetStencilReference = _VkCmdSetStencilReference {-# INLINE _VkCmdSetStencilReference #-} _VkCmdSetStencilReference :: CString _VkCmdSetStencilReference = Ptr "vkCmdSetStencilReference\NUL"# {-# INLINE is_VkCmdSetStencilReference #-} is_VkCmdSetStencilReference :: CString -> Bool is_VkCmdSetStencilReference = (EQ ==) . cmpCStrings _VkCmdSetStencilReference type VkCmdSetStencilReference = "vkCmdSetStencilReference" -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetStencilReference -- > ( VkCommandBuffer commandBuffer -- > , VkStencilFaceFlags faceMask -- > , uint32_t reference -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetStencilReference vkCmdSetStencilReference registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetStencilReference <- vkGetInstanceProc @VkCmdSetStencilReference vkInstance -- -- or less efficient: -- -- > myCmdSetStencilReference <- vkGetProc @VkCmdSetStencilReference -- -- __Note:__ @vkCmdSetStencilReferenceUnsafe@ and @vkCmdSetStencilReferenceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetStencilReference@ is an alias -- of @vkCmdSetStencilReferenceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetStencilReferenceSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdSetStencilReference" vkCmdSetStencilReferenceUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkStencilFaceFlags -- ^ faceMask -> Word32 -- ^ reference -> IO () #else vkCmdSetStencilReferenceUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkStencilFaceFlags -- ^ faceMask -> Word32 -- ^ reference -> IO () vkCmdSetStencilReferenceUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdSetStencilReference) {-# NOINLINE vkCmdSetStencilReferenceUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetStencilReference -- > ( VkCommandBuffer commandBuffer -- > , VkStencilFaceFlags faceMask -- > , uint32_t reference -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetStencilReference vkCmdSetStencilReference registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetStencilReference <- vkGetInstanceProc @VkCmdSetStencilReference vkInstance -- -- or less efficient: -- -- > myCmdSetStencilReference <- vkGetProc @VkCmdSetStencilReference -- -- __Note:__ @vkCmdSetStencilReferenceUnsafe@ and @vkCmdSetStencilReferenceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetStencilReference@ is an alias -- of @vkCmdSetStencilReferenceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetStencilReferenceSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdSetStencilReference" vkCmdSetStencilReferenceSafe :: VkCommandBuffer -- ^ commandBuffer -> VkStencilFaceFlags -- ^ faceMask -> Word32 -- ^ reference -> IO () #else vkCmdSetStencilReferenceSafe :: VkCommandBuffer -- ^ commandBuffer -> VkStencilFaceFlags -- ^ faceMask -> Word32 -- ^ reference -> IO () vkCmdSetStencilReferenceSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdSetStencilReference) {-# NOINLINE vkCmdSetStencilReferenceSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetStencilReference -- > ( VkCommandBuffer commandBuffer -- > , VkStencilFaceFlags faceMask -- > , uint32_t reference -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetStencilReference vkCmdSetStencilReference registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetStencilReference <- vkGetInstanceProc @VkCmdSetStencilReference vkInstance -- -- or less efficient: -- -- > myCmdSetStencilReference <- vkGetProc @VkCmdSetStencilReference -- -- __Note:__ @vkCmdSetStencilReferenceUnsafe@ and @vkCmdSetStencilReferenceSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetStencilReference@ is an alias -- of @vkCmdSetStencilReferenceUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetStencilReferenceSafe@. -- vkCmdSetStencilReference :: VkCommandBuffer -- ^ commandBuffer -> VkStencilFaceFlags -- ^ faceMask -> Word32 -- ^ reference -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdSetStencilReference = vkCmdSetStencilReferenceUnsafe #else vkCmdSetStencilReference = vkCmdSetStencilReferenceSafe #endif {-# INLINE vkCmdSetStencilReference #-} -- | Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdSetStencilReference -- > ( VkCommandBuffer commandBuffer -- > , VkStencilFaceFlags faceMask -- > , uint32_t reference -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetStencilReference vkCmdSetStencilReference registry at www.khronos.org> type HS_vkCmdSetStencilReference = VkCommandBuffer -- ^ commandBuffer -> VkStencilFaceFlags -- ^ faceMask -> Word32 -- ^ reference -> IO () type PFN_vkCmdSetStencilReference = FunPtr HS_vkCmdSetStencilReference foreign import ccall unsafe "dynamic" unwrapVkCmdSetStencilReferenceUnsafe :: PFN_vkCmdSetStencilReference -> HS_vkCmdSetStencilReference foreign import ccall safe "dynamic" unwrapVkCmdSetStencilReferenceSafe :: PFN_vkCmdSetStencilReference -> HS_vkCmdSetStencilReference instance VulkanProc "vkCmdSetStencilReference" where type VkProcType "vkCmdSetStencilReference" = HS_vkCmdSetStencilReference vkProcSymbol = _VkCmdSetStencilReference {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdSetStencilReferenceUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdSetStencilReferenceSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdBindDescriptorSets :: CString pattern VkCmdBindDescriptorSets <- (is_VkCmdBindDescriptorSets -> True) where VkCmdBindDescriptorSets = _VkCmdBindDescriptorSets {-# INLINE _VkCmdBindDescriptorSets #-} _VkCmdBindDescriptorSets :: CString _VkCmdBindDescriptorSets = Ptr "vkCmdBindDescriptorSets\NUL"# {-# INLINE is_VkCmdBindDescriptorSets #-} is_VkCmdBindDescriptorSets :: CString -> Bool is_VkCmdBindDescriptorSets = (EQ ==) . cmpCStrings _VkCmdBindDescriptorSets type VkCmdBindDescriptorSets = "vkCmdBindDescriptorSets" -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdBindDescriptorSets -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineBindPoint pipelineBindPoint -- > , VkPipelineLayout layout -- > , uint32_t firstSet -- > , uint32_t descriptorSetCount -- > , const VkDescriptorSet* pDescriptorSets -- > , uint32_t dynamicOffsetCount -- > , const uint32_t* pDynamicOffsets -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBindDescriptorSets vkCmdBindDescriptorSets registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBindDescriptorSets <- vkGetInstanceProc @VkCmdBindDescriptorSets vkInstance -- -- or less efficient: -- -- > myCmdBindDescriptorSets <- vkGetProc @VkCmdBindDescriptorSets -- -- __Note:__ @vkCmdBindDescriptorSetsUnsafe@ and @vkCmdBindDescriptorSetsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBindDescriptorSets@ is an alias -- of @vkCmdBindDescriptorSetsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBindDescriptorSetsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdBindDescriptorSets" vkCmdBindDescriptorSetsUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineBindPoint -- ^ pipelineBindPoint -> VkPipelineLayout -- ^ layout -> Word32 -- ^ firstSet -> Word32 -- ^ descriptorSetCount -> Ptr VkDescriptorSet -- ^ pDescriptorSets -> Word32 -- ^ dynamicOffsetCount -> Ptr Word32 -- ^ pDynamicOffsets -> IO () #else vkCmdBindDescriptorSetsUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineBindPoint -- ^ pipelineBindPoint -> VkPipelineLayout -- ^ layout -> Word32 -- ^ firstSet -> Word32 -- ^ descriptorSetCount -> Ptr VkDescriptorSet -- ^ pDescriptorSets -> Word32 -- ^ dynamicOffsetCount -> Ptr Word32 -- ^ pDynamicOffsets -> IO () vkCmdBindDescriptorSetsUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdBindDescriptorSets) {-# NOINLINE vkCmdBindDescriptorSetsUnsafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdBindDescriptorSets -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineBindPoint pipelineBindPoint -- > , VkPipelineLayout layout -- > , uint32_t firstSet -- > , uint32_t descriptorSetCount -- > , const VkDescriptorSet* pDescriptorSets -- > , uint32_t dynamicOffsetCount -- > , const uint32_t* pDynamicOffsets -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBindDescriptorSets vkCmdBindDescriptorSets registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBindDescriptorSets <- vkGetInstanceProc @VkCmdBindDescriptorSets vkInstance -- -- or less efficient: -- -- > myCmdBindDescriptorSets <- vkGetProc @VkCmdBindDescriptorSets -- -- __Note:__ @vkCmdBindDescriptorSetsUnsafe@ and @vkCmdBindDescriptorSetsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBindDescriptorSets@ is an alias -- of @vkCmdBindDescriptorSetsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBindDescriptorSetsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdBindDescriptorSets" vkCmdBindDescriptorSetsSafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineBindPoint -- ^ pipelineBindPoint -> VkPipelineLayout -- ^ layout -> Word32 -- ^ firstSet -> Word32 -- ^ descriptorSetCount -> Ptr VkDescriptorSet -- ^ pDescriptorSets -> Word32 -- ^ dynamicOffsetCount -> Ptr Word32 -- ^ pDynamicOffsets -> IO () #else vkCmdBindDescriptorSetsSafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineBindPoint -- ^ pipelineBindPoint -> VkPipelineLayout -- ^ layout -> Word32 -- ^ firstSet -> Word32 -- ^ descriptorSetCount -> Ptr VkDescriptorSet -- ^ pDescriptorSets -> Word32 -- ^ dynamicOffsetCount -> Ptr Word32 -- ^ pDynamicOffsets -> IO () vkCmdBindDescriptorSetsSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdBindDescriptorSets) {-# NOINLINE vkCmdBindDescriptorSetsSafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdBindDescriptorSets -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineBindPoint pipelineBindPoint -- > , VkPipelineLayout layout -- > , uint32_t firstSet -- > , uint32_t descriptorSetCount -- > , const VkDescriptorSet* pDescriptorSets -- > , uint32_t dynamicOffsetCount -- > , const uint32_t* pDynamicOffsets -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBindDescriptorSets vkCmdBindDescriptorSets registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBindDescriptorSets <- vkGetInstanceProc @VkCmdBindDescriptorSets vkInstance -- -- or less efficient: -- -- > myCmdBindDescriptorSets <- vkGetProc @VkCmdBindDescriptorSets -- -- __Note:__ @vkCmdBindDescriptorSetsUnsafe@ and @vkCmdBindDescriptorSetsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBindDescriptorSets@ is an alias -- of @vkCmdBindDescriptorSetsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBindDescriptorSetsSafe@. -- vkCmdBindDescriptorSets :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineBindPoint -- ^ pipelineBindPoint -> VkPipelineLayout -- ^ layout -> Word32 -- ^ firstSet -> Word32 -- ^ descriptorSetCount -> Ptr VkDescriptorSet -- ^ pDescriptorSets -> Word32 -- ^ dynamicOffsetCount -> Ptr Word32 -- ^ pDynamicOffsets -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdBindDescriptorSets = vkCmdBindDescriptorSetsUnsafe #else vkCmdBindDescriptorSets = vkCmdBindDescriptorSetsSafe #endif {-# INLINE vkCmdBindDescriptorSets #-} -- | Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdBindDescriptorSets -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineBindPoint pipelineBindPoint -- > , VkPipelineLayout layout -- > , uint32_t firstSet -- > , uint32_t descriptorSetCount -- > , const VkDescriptorSet* pDescriptorSets -- > , uint32_t dynamicOffsetCount -- > , const uint32_t* pDynamicOffsets -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBindDescriptorSets vkCmdBindDescriptorSets registry at www.khronos.org> type HS_vkCmdBindDescriptorSets = VkCommandBuffer -- ^ commandBuffer -> VkPipelineBindPoint -- ^ pipelineBindPoint -> VkPipelineLayout -- ^ layout -> Word32 -- ^ firstSet -> Word32 -- ^ descriptorSetCount -> Ptr VkDescriptorSet -- ^ pDescriptorSets -> Word32 -- ^ dynamicOffsetCount -> Ptr Word32 -- ^ pDynamicOffsets -> IO () type PFN_vkCmdBindDescriptorSets = FunPtr HS_vkCmdBindDescriptorSets foreign import ccall unsafe "dynamic" unwrapVkCmdBindDescriptorSetsUnsafe :: PFN_vkCmdBindDescriptorSets -> HS_vkCmdBindDescriptorSets foreign import ccall safe "dynamic" unwrapVkCmdBindDescriptorSetsSafe :: PFN_vkCmdBindDescriptorSets -> HS_vkCmdBindDescriptorSets instance VulkanProc "vkCmdBindDescriptorSets" where type VkProcType "vkCmdBindDescriptorSets" = HS_vkCmdBindDescriptorSets vkProcSymbol = _VkCmdBindDescriptorSets {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdBindDescriptorSetsUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdBindDescriptorSetsSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdBindIndexBuffer :: CString pattern VkCmdBindIndexBuffer <- (is_VkCmdBindIndexBuffer -> True) where VkCmdBindIndexBuffer = _VkCmdBindIndexBuffer {-# INLINE _VkCmdBindIndexBuffer #-} _VkCmdBindIndexBuffer :: CString _VkCmdBindIndexBuffer = Ptr "vkCmdBindIndexBuffer\NUL"# {-# INLINE is_VkCmdBindIndexBuffer #-} is_VkCmdBindIndexBuffer :: CString -> Bool is_VkCmdBindIndexBuffer = (EQ ==) . cmpCStrings _VkCmdBindIndexBuffer type VkCmdBindIndexBuffer = "vkCmdBindIndexBuffer" -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdBindIndexBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer buffer -- > , VkDeviceSize offset -- > , VkIndexType indexType -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBindIndexBuffer vkCmdBindIndexBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBindIndexBuffer <- vkGetInstanceProc @VkCmdBindIndexBuffer vkInstance -- -- or less efficient: -- -- > myCmdBindIndexBuffer <- vkGetProc @VkCmdBindIndexBuffer -- -- __Note:__ @vkCmdBindIndexBufferUnsafe@ and @vkCmdBindIndexBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBindIndexBuffer@ is an alias -- of @vkCmdBindIndexBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBindIndexBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdBindIndexBuffer" vkCmdBindIndexBufferUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> VkIndexType -- ^ indexType -> IO () #else vkCmdBindIndexBufferUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> VkIndexType -- ^ indexType -> IO () vkCmdBindIndexBufferUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdBindIndexBuffer) {-# NOINLINE vkCmdBindIndexBufferUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdBindIndexBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer buffer -- > , VkDeviceSize offset -- > , VkIndexType indexType -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBindIndexBuffer vkCmdBindIndexBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBindIndexBuffer <- vkGetInstanceProc @VkCmdBindIndexBuffer vkInstance -- -- or less efficient: -- -- > myCmdBindIndexBuffer <- vkGetProc @VkCmdBindIndexBuffer -- -- __Note:__ @vkCmdBindIndexBufferUnsafe@ and @vkCmdBindIndexBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBindIndexBuffer@ is an alias -- of @vkCmdBindIndexBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBindIndexBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdBindIndexBuffer" vkCmdBindIndexBufferSafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> VkIndexType -- ^ indexType -> IO () #else vkCmdBindIndexBufferSafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> VkIndexType -- ^ indexType -> IO () vkCmdBindIndexBufferSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdBindIndexBuffer) {-# NOINLINE vkCmdBindIndexBufferSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdBindIndexBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer buffer -- > , VkDeviceSize offset -- > , VkIndexType indexType -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBindIndexBuffer vkCmdBindIndexBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBindIndexBuffer <- vkGetInstanceProc @VkCmdBindIndexBuffer vkInstance -- -- or less efficient: -- -- > myCmdBindIndexBuffer <- vkGetProc @VkCmdBindIndexBuffer -- -- __Note:__ @vkCmdBindIndexBufferUnsafe@ and @vkCmdBindIndexBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBindIndexBuffer@ is an alias -- of @vkCmdBindIndexBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBindIndexBufferSafe@. -- vkCmdBindIndexBuffer :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> VkIndexType -- ^ indexType -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdBindIndexBuffer = vkCmdBindIndexBufferUnsafe #else vkCmdBindIndexBuffer = vkCmdBindIndexBufferSafe #endif {-# INLINE vkCmdBindIndexBuffer #-} -- | Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdBindIndexBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer buffer -- > , VkDeviceSize offset -- > , VkIndexType indexType -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBindIndexBuffer vkCmdBindIndexBuffer registry at www.khronos.org> type HS_vkCmdBindIndexBuffer = VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> VkIndexType -- ^ indexType -> IO () type PFN_vkCmdBindIndexBuffer = FunPtr HS_vkCmdBindIndexBuffer foreign import ccall unsafe "dynamic" unwrapVkCmdBindIndexBufferUnsafe :: PFN_vkCmdBindIndexBuffer -> HS_vkCmdBindIndexBuffer foreign import ccall safe "dynamic" unwrapVkCmdBindIndexBufferSafe :: PFN_vkCmdBindIndexBuffer -> HS_vkCmdBindIndexBuffer instance VulkanProc "vkCmdBindIndexBuffer" where type VkProcType "vkCmdBindIndexBuffer" = HS_vkCmdBindIndexBuffer vkProcSymbol = _VkCmdBindIndexBuffer {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdBindIndexBufferUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdBindIndexBufferSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdBindVertexBuffers :: CString pattern VkCmdBindVertexBuffers <- (is_VkCmdBindVertexBuffers -> True) where VkCmdBindVertexBuffers = _VkCmdBindVertexBuffers {-# INLINE _VkCmdBindVertexBuffers #-} _VkCmdBindVertexBuffers :: CString _VkCmdBindVertexBuffers = Ptr "vkCmdBindVertexBuffers\NUL"# {-# INLINE is_VkCmdBindVertexBuffers #-} is_VkCmdBindVertexBuffers :: CString -> Bool is_VkCmdBindVertexBuffers = (EQ ==) . cmpCStrings _VkCmdBindVertexBuffers type VkCmdBindVertexBuffers = "vkCmdBindVertexBuffers" -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdBindVertexBuffers -- > ( VkCommandBuffer commandBuffer -- > , uint32_t firstBinding -- > , uint32_t bindingCount -- > , const VkBuffer* pBuffers -- > , const VkDeviceSize* pOffsets -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBindVertexBuffers vkCmdBindVertexBuffers registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBindVertexBuffers <- vkGetInstanceProc @VkCmdBindVertexBuffers vkInstance -- -- or less efficient: -- -- > myCmdBindVertexBuffers <- vkGetProc @VkCmdBindVertexBuffers -- -- __Note:__ @vkCmdBindVertexBuffersUnsafe@ and @vkCmdBindVertexBuffersSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBindVertexBuffers@ is an alias -- of @vkCmdBindVertexBuffersUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBindVertexBuffersSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdBindVertexBuffers" vkCmdBindVertexBuffersUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ firstBinding -> Word32 -- ^ bindingCount -> Ptr VkBuffer -- ^ pBuffers -> Ptr VkDeviceSize -- ^ pOffsets -> IO () #else vkCmdBindVertexBuffersUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ firstBinding -> Word32 -- ^ bindingCount -> Ptr VkBuffer -- ^ pBuffers -> Ptr VkDeviceSize -- ^ pOffsets -> IO () vkCmdBindVertexBuffersUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdBindVertexBuffers) {-# NOINLINE vkCmdBindVertexBuffersUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdBindVertexBuffers -- > ( VkCommandBuffer commandBuffer -- > , uint32_t firstBinding -- > , uint32_t bindingCount -- > , const VkBuffer* pBuffers -- > , const VkDeviceSize* pOffsets -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBindVertexBuffers vkCmdBindVertexBuffers registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBindVertexBuffers <- vkGetInstanceProc @VkCmdBindVertexBuffers vkInstance -- -- or less efficient: -- -- > myCmdBindVertexBuffers <- vkGetProc @VkCmdBindVertexBuffers -- -- __Note:__ @vkCmdBindVertexBuffersUnsafe@ and @vkCmdBindVertexBuffersSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBindVertexBuffers@ is an alias -- of @vkCmdBindVertexBuffersUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBindVertexBuffersSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdBindVertexBuffers" vkCmdBindVertexBuffersSafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ firstBinding -> Word32 -- ^ bindingCount -> Ptr VkBuffer -- ^ pBuffers -> Ptr VkDeviceSize -- ^ pOffsets -> IO () #else vkCmdBindVertexBuffersSafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ firstBinding -> Word32 -- ^ bindingCount -> Ptr VkBuffer -- ^ pBuffers -> Ptr VkDeviceSize -- ^ pOffsets -> IO () vkCmdBindVertexBuffersSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdBindVertexBuffers) {-# NOINLINE vkCmdBindVertexBuffersSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdBindVertexBuffers -- > ( VkCommandBuffer commandBuffer -- > , uint32_t firstBinding -- > , uint32_t bindingCount -- > , const VkBuffer* pBuffers -- > , const VkDeviceSize* pOffsets -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBindVertexBuffers vkCmdBindVertexBuffers registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBindVertexBuffers <- vkGetInstanceProc @VkCmdBindVertexBuffers vkInstance -- -- or less efficient: -- -- > myCmdBindVertexBuffers <- vkGetProc @VkCmdBindVertexBuffers -- -- __Note:__ @vkCmdBindVertexBuffersUnsafe@ and @vkCmdBindVertexBuffersSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBindVertexBuffers@ is an alias -- of @vkCmdBindVertexBuffersUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBindVertexBuffersSafe@. -- vkCmdBindVertexBuffers :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ firstBinding -> Word32 -- ^ bindingCount -> Ptr VkBuffer -- ^ pBuffers -> Ptr VkDeviceSize -- ^ pOffsets -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdBindVertexBuffers = vkCmdBindVertexBuffersUnsafe #else vkCmdBindVertexBuffers = vkCmdBindVertexBuffersSafe #endif {-# INLINE vkCmdBindVertexBuffers #-} -- | Queues: 'graphics'. -- -- Renderpass: @both@ -- -- > void vkCmdBindVertexBuffers -- > ( VkCommandBuffer commandBuffer -- > , uint32_t firstBinding -- > , uint32_t bindingCount -- > , const VkBuffer* pBuffers -- > , const VkDeviceSize* pOffsets -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBindVertexBuffers vkCmdBindVertexBuffers registry at www.khronos.org> type HS_vkCmdBindVertexBuffers = VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ firstBinding -> Word32 -- ^ bindingCount -> Ptr VkBuffer -- ^ pBuffers -> Ptr VkDeviceSize -- ^ pOffsets -> IO () type PFN_vkCmdBindVertexBuffers = FunPtr HS_vkCmdBindVertexBuffers foreign import ccall unsafe "dynamic" unwrapVkCmdBindVertexBuffersUnsafe :: PFN_vkCmdBindVertexBuffers -> HS_vkCmdBindVertexBuffers foreign import ccall safe "dynamic" unwrapVkCmdBindVertexBuffersSafe :: PFN_vkCmdBindVertexBuffers -> HS_vkCmdBindVertexBuffers instance VulkanProc "vkCmdBindVertexBuffers" where type VkProcType "vkCmdBindVertexBuffers" = HS_vkCmdBindVertexBuffers vkProcSymbol = _VkCmdBindVertexBuffers {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdBindVertexBuffersUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdBindVertexBuffersSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdDraw :: CString pattern VkCmdDraw <- (is_VkCmdDraw -> True) where VkCmdDraw = _VkCmdDraw {-# INLINE _VkCmdDraw #-} _VkCmdDraw :: CString _VkCmdDraw = Ptr "vkCmdDraw\NUL"# {-# INLINE is_VkCmdDraw #-} is_VkCmdDraw :: CString -> Bool is_VkCmdDraw = (EQ ==) . cmpCStrings _VkCmdDraw type VkCmdDraw = "vkCmdDraw" -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdDraw -- > ( VkCommandBuffer commandBuffer -- > , uint32_t vertexCount -- > , uint32_t instanceCount -- > , uint32_t firstVertex -- > , uint32_t firstInstance -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDraw vkCmdDraw registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdDraw <- vkGetInstanceProc @VkCmdDraw vkInstance -- -- or less efficient: -- -- > myCmdDraw <- vkGetProc @VkCmdDraw -- -- __Note:__ @vkCmdDrawUnsafe@ and @vkCmdDrawSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdDraw@ is an alias -- of @vkCmdDrawUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdDrawSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdDraw" vkCmdDrawUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ vertexCount -> Word32 -- ^ instanceCount -> Word32 -- ^ firstVertex -> Word32 -- ^ firstInstance -> IO () #else vkCmdDrawUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ vertexCount -> Word32 -- ^ instanceCount -> Word32 -- ^ firstVertex -> Word32 -- ^ firstInstance -> IO () vkCmdDrawUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdDraw) {-# NOINLINE vkCmdDrawUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdDraw -- > ( VkCommandBuffer commandBuffer -- > , uint32_t vertexCount -- > , uint32_t instanceCount -- > , uint32_t firstVertex -- > , uint32_t firstInstance -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDraw vkCmdDraw registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdDraw <- vkGetInstanceProc @VkCmdDraw vkInstance -- -- or less efficient: -- -- > myCmdDraw <- vkGetProc @VkCmdDraw -- -- __Note:__ @vkCmdDrawUnsafe@ and @vkCmdDrawSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdDraw@ is an alias -- of @vkCmdDrawUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdDrawSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdDraw" vkCmdDrawSafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ vertexCount -> Word32 -- ^ instanceCount -> Word32 -- ^ firstVertex -> Word32 -- ^ firstInstance -> IO () #else vkCmdDrawSafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ vertexCount -> Word32 -- ^ instanceCount -> Word32 -- ^ firstVertex -> Word32 -- ^ firstInstance -> IO () vkCmdDrawSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdDraw) {-# NOINLINE vkCmdDrawSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdDraw -- > ( VkCommandBuffer commandBuffer -- > , uint32_t vertexCount -- > , uint32_t instanceCount -- > , uint32_t firstVertex -- > , uint32_t firstInstance -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDraw vkCmdDraw registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdDraw <- vkGetInstanceProc @VkCmdDraw vkInstance -- -- or less efficient: -- -- > myCmdDraw <- vkGetProc @VkCmdDraw -- -- __Note:__ @vkCmdDrawUnsafe@ and @vkCmdDrawSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdDraw@ is an alias -- of @vkCmdDrawUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdDrawSafe@. -- vkCmdDraw :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ vertexCount -> Word32 -- ^ instanceCount -> Word32 -- ^ firstVertex -> Word32 -- ^ firstInstance -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdDraw = vkCmdDrawUnsafe #else vkCmdDraw = vkCmdDrawSafe #endif {-# INLINE vkCmdDraw #-} -- | Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdDraw -- > ( VkCommandBuffer commandBuffer -- > , uint32_t vertexCount -- > , uint32_t instanceCount -- > , uint32_t firstVertex -- > , uint32_t firstInstance -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDraw vkCmdDraw registry at www.khronos.org> type HS_vkCmdDraw = VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ vertexCount -> Word32 -- ^ instanceCount -> Word32 -- ^ firstVertex -> Word32 -- ^ firstInstance -> IO () type PFN_vkCmdDraw = FunPtr HS_vkCmdDraw foreign import ccall unsafe "dynamic" unwrapVkCmdDrawUnsafe :: PFN_vkCmdDraw -> HS_vkCmdDraw foreign import ccall safe "dynamic" unwrapVkCmdDrawSafe :: PFN_vkCmdDraw -> HS_vkCmdDraw instance VulkanProc "vkCmdDraw" where type VkProcType "vkCmdDraw" = HS_vkCmdDraw vkProcSymbol = _VkCmdDraw {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdDrawUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdDrawSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdDrawIndexed :: CString pattern VkCmdDrawIndexed <- (is_VkCmdDrawIndexed -> True) where VkCmdDrawIndexed = _VkCmdDrawIndexed {-# INLINE _VkCmdDrawIndexed #-} _VkCmdDrawIndexed :: CString _VkCmdDrawIndexed = Ptr "vkCmdDrawIndexed\NUL"# {-# INLINE is_VkCmdDrawIndexed #-} is_VkCmdDrawIndexed :: CString -> Bool is_VkCmdDrawIndexed = (EQ ==) . cmpCStrings _VkCmdDrawIndexed type VkCmdDrawIndexed = "vkCmdDrawIndexed" -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdDrawIndexed -- > ( VkCommandBuffer commandBuffer -- > , uint32_t indexCount -- > , uint32_t instanceCount -- > , uint32_t firstIndex -- > , int32_t vertexOffset -- > , uint32_t firstInstance -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDrawIndexed vkCmdDrawIndexed registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdDrawIndexed <- vkGetInstanceProc @VkCmdDrawIndexed vkInstance -- -- or less efficient: -- -- > myCmdDrawIndexed <- vkGetProc @VkCmdDrawIndexed -- -- __Note:__ @vkCmdDrawIndexedUnsafe@ and @vkCmdDrawIndexedSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdDrawIndexed@ is an alias -- of @vkCmdDrawIndexedUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdDrawIndexedSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdDrawIndexed" vkCmdDrawIndexedUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ indexCount -> Word32 -- ^ instanceCount -> Word32 -- ^ firstIndex -> Int32 -- ^ vertexOffset -> Word32 -- ^ firstInstance -> IO () #else vkCmdDrawIndexedUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ indexCount -> Word32 -- ^ instanceCount -> Word32 -- ^ firstIndex -> Int32 -- ^ vertexOffset -> Word32 -- ^ firstInstance -> IO () vkCmdDrawIndexedUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdDrawIndexed) {-# NOINLINE vkCmdDrawIndexedUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdDrawIndexed -- > ( VkCommandBuffer commandBuffer -- > , uint32_t indexCount -- > , uint32_t instanceCount -- > , uint32_t firstIndex -- > , int32_t vertexOffset -- > , uint32_t firstInstance -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDrawIndexed vkCmdDrawIndexed registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdDrawIndexed <- vkGetInstanceProc @VkCmdDrawIndexed vkInstance -- -- or less efficient: -- -- > myCmdDrawIndexed <- vkGetProc @VkCmdDrawIndexed -- -- __Note:__ @vkCmdDrawIndexedUnsafe@ and @vkCmdDrawIndexedSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdDrawIndexed@ is an alias -- of @vkCmdDrawIndexedUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdDrawIndexedSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdDrawIndexed" vkCmdDrawIndexedSafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ indexCount -> Word32 -- ^ instanceCount -> Word32 -- ^ firstIndex -> Int32 -- ^ vertexOffset -> Word32 -- ^ firstInstance -> IO () #else vkCmdDrawIndexedSafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ indexCount -> Word32 -- ^ instanceCount -> Word32 -- ^ firstIndex -> Int32 -- ^ vertexOffset -> Word32 -- ^ firstInstance -> IO () vkCmdDrawIndexedSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdDrawIndexed) {-# NOINLINE vkCmdDrawIndexedSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdDrawIndexed -- > ( VkCommandBuffer commandBuffer -- > , uint32_t indexCount -- > , uint32_t instanceCount -- > , uint32_t firstIndex -- > , int32_t vertexOffset -- > , uint32_t firstInstance -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDrawIndexed vkCmdDrawIndexed registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdDrawIndexed <- vkGetInstanceProc @VkCmdDrawIndexed vkInstance -- -- or less efficient: -- -- > myCmdDrawIndexed <- vkGetProc @VkCmdDrawIndexed -- -- __Note:__ @vkCmdDrawIndexedUnsafe@ and @vkCmdDrawIndexedSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdDrawIndexed@ is an alias -- of @vkCmdDrawIndexedUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdDrawIndexedSafe@. -- vkCmdDrawIndexed :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ indexCount -> Word32 -- ^ instanceCount -> Word32 -- ^ firstIndex -> Int32 -- ^ vertexOffset -> Word32 -- ^ firstInstance -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdDrawIndexed = vkCmdDrawIndexedUnsafe #else vkCmdDrawIndexed = vkCmdDrawIndexedSafe #endif {-# INLINE vkCmdDrawIndexed #-} -- | Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdDrawIndexed -- > ( VkCommandBuffer commandBuffer -- > , uint32_t indexCount -- > , uint32_t instanceCount -- > , uint32_t firstIndex -- > , int32_t vertexOffset -- > , uint32_t firstInstance -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDrawIndexed vkCmdDrawIndexed registry at www.khronos.org> type HS_vkCmdDrawIndexed = VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ indexCount -> Word32 -- ^ instanceCount -> Word32 -- ^ firstIndex -> Int32 -- ^ vertexOffset -> Word32 -- ^ firstInstance -> IO () type PFN_vkCmdDrawIndexed = FunPtr HS_vkCmdDrawIndexed foreign import ccall unsafe "dynamic" unwrapVkCmdDrawIndexedUnsafe :: PFN_vkCmdDrawIndexed -> HS_vkCmdDrawIndexed foreign import ccall safe "dynamic" unwrapVkCmdDrawIndexedSafe :: PFN_vkCmdDrawIndexed -> HS_vkCmdDrawIndexed instance VulkanProc "vkCmdDrawIndexed" where type VkProcType "vkCmdDrawIndexed" = HS_vkCmdDrawIndexed vkProcSymbol = _VkCmdDrawIndexed {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdDrawIndexedUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdDrawIndexedSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdDrawIndirect :: CString pattern VkCmdDrawIndirect <- (is_VkCmdDrawIndirect -> True) where VkCmdDrawIndirect = _VkCmdDrawIndirect {-# INLINE _VkCmdDrawIndirect #-} _VkCmdDrawIndirect :: CString _VkCmdDrawIndirect = Ptr "vkCmdDrawIndirect\NUL"# {-# INLINE is_VkCmdDrawIndirect #-} is_VkCmdDrawIndirect :: CString -> Bool is_VkCmdDrawIndirect = (EQ ==) . cmpCStrings _VkCmdDrawIndirect type VkCmdDrawIndirect = "vkCmdDrawIndirect" -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdDrawIndirect -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer buffer -- > , VkDeviceSize offset -- > , uint32_t drawCount -- > , uint32_t stride -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDrawIndirect vkCmdDrawIndirect registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdDrawIndirect <- vkGetInstanceProc @VkCmdDrawIndirect vkInstance -- -- or less efficient: -- -- > myCmdDrawIndirect <- vkGetProc @VkCmdDrawIndirect -- -- __Note:__ @vkCmdDrawIndirectUnsafe@ and @vkCmdDrawIndirectSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdDrawIndirect@ is an alias -- of @vkCmdDrawIndirectUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdDrawIndirectSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdDrawIndirect" vkCmdDrawIndirectUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> Word32 -- ^ drawCount -> Word32 -- ^ stride -> IO () #else vkCmdDrawIndirectUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> Word32 -- ^ drawCount -> Word32 -- ^ stride -> IO () vkCmdDrawIndirectUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdDrawIndirect) {-# NOINLINE vkCmdDrawIndirectUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdDrawIndirect -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer buffer -- > , VkDeviceSize offset -- > , uint32_t drawCount -- > , uint32_t stride -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDrawIndirect vkCmdDrawIndirect registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdDrawIndirect <- vkGetInstanceProc @VkCmdDrawIndirect vkInstance -- -- or less efficient: -- -- > myCmdDrawIndirect <- vkGetProc @VkCmdDrawIndirect -- -- __Note:__ @vkCmdDrawIndirectUnsafe@ and @vkCmdDrawIndirectSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdDrawIndirect@ is an alias -- of @vkCmdDrawIndirectUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdDrawIndirectSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdDrawIndirect" vkCmdDrawIndirectSafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> Word32 -- ^ drawCount -> Word32 -- ^ stride -> IO () #else vkCmdDrawIndirectSafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> Word32 -- ^ drawCount -> Word32 -- ^ stride -> IO () vkCmdDrawIndirectSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdDrawIndirect) {-# NOINLINE vkCmdDrawIndirectSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdDrawIndirect -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer buffer -- > , VkDeviceSize offset -- > , uint32_t drawCount -- > , uint32_t stride -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDrawIndirect vkCmdDrawIndirect registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdDrawIndirect <- vkGetInstanceProc @VkCmdDrawIndirect vkInstance -- -- or less efficient: -- -- > myCmdDrawIndirect <- vkGetProc @VkCmdDrawIndirect -- -- __Note:__ @vkCmdDrawIndirectUnsafe@ and @vkCmdDrawIndirectSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdDrawIndirect@ is an alias -- of @vkCmdDrawIndirectUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdDrawIndirectSafe@. -- vkCmdDrawIndirect :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> Word32 -- ^ drawCount -> Word32 -- ^ stride -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdDrawIndirect = vkCmdDrawIndirectUnsafe #else vkCmdDrawIndirect = vkCmdDrawIndirectSafe #endif {-# INLINE vkCmdDrawIndirect #-} -- | Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdDrawIndirect -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer buffer -- > , VkDeviceSize offset -- > , uint32_t drawCount -- > , uint32_t stride -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDrawIndirect vkCmdDrawIndirect registry at www.khronos.org> type HS_vkCmdDrawIndirect = VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> Word32 -- ^ drawCount -> Word32 -- ^ stride -> IO () type PFN_vkCmdDrawIndirect = FunPtr HS_vkCmdDrawIndirect foreign import ccall unsafe "dynamic" unwrapVkCmdDrawIndirectUnsafe :: PFN_vkCmdDrawIndirect -> HS_vkCmdDrawIndirect foreign import ccall safe "dynamic" unwrapVkCmdDrawIndirectSafe :: PFN_vkCmdDrawIndirect -> HS_vkCmdDrawIndirect instance VulkanProc "vkCmdDrawIndirect" where type VkProcType "vkCmdDrawIndirect" = HS_vkCmdDrawIndirect vkProcSymbol = _VkCmdDrawIndirect {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdDrawIndirectUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdDrawIndirectSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdDrawIndexedIndirect :: CString pattern VkCmdDrawIndexedIndirect <- (is_VkCmdDrawIndexedIndirect -> True) where VkCmdDrawIndexedIndirect = _VkCmdDrawIndexedIndirect {-# INLINE _VkCmdDrawIndexedIndirect #-} _VkCmdDrawIndexedIndirect :: CString _VkCmdDrawIndexedIndirect = Ptr "vkCmdDrawIndexedIndirect\NUL"# {-# INLINE is_VkCmdDrawIndexedIndirect #-} is_VkCmdDrawIndexedIndirect :: CString -> Bool is_VkCmdDrawIndexedIndirect = (EQ ==) . cmpCStrings _VkCmdDrawIndexedIndirect type VkCmdDrawIndexedIndirect = "vkCmdDrawIndexedIndirect" -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdDrawIndexedIndirect -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer buffer -- > , VkDeviceSize offset -- > , uint32_t drawCount -- > , uint32_t stride -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdDrawIndexedIndirect <- vkGetInstanceProc @VkCmdDrawIndexedIndirect vkInstance -- -- or less efficient: -- -- > myCmdDrawIndexedIndirect <- vkGetProc @VkCmdDrawIndexedIndirect -- -- __Note:__ @vkCmdDrawIndexedIndirectUnsafe@ and @vkCmdDrawIndexedIndirectSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdDrawIndexedIndirect@ is an alias -- of @vkCmdDrawIndexedIndirectUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdDrawIndexedIndirectSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdDrawIndexedIndirect" vkCmdDrawIndexedIndirectUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> Word32 -- ^ drawCount -> Word32 -- ^ stride -> IO () #else vkCmdDrawIndexedIndirectUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> Word32 -- ^ drawCount -> Word32 -- ^ stride -> IO () vkCmdDrawIndexedIndirectUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdDrawIndexedIndirect) {-# NOINLINE vkCmdDrawIndexedIndirectUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdDrawIndexedIndirect -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer buffer -- > , VkDeviceSize offset -- > , uint32_t drawCount -- > , uint32_t stride -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdDrawIndexedIndirect <- vkGetInstanceProc @VkCmdDrawIndexedIndirect vkInstance -- -- or less efficient: -- -- > myCmdDrawIndexedIndirect <- vkGetProc @VkCmdDrawIndexedIndirect -- -- __Note:__ @vkCmdDrawIndexedIndirectUnsafe@ and @vkCmdDrawIndexedIndirectSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdDrawIndexedIndirect@ is an alias -- of @vkCmdDrawIndexedIndirectUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdDrawIndexedIndirectSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdDrawIndexedIndirect" vkCmdDrawIndexedIndirectSafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> Word32 -- ^ drawCount -> Word32 -- ^ stride -> IO () #else vkCmdDrawIndexedIndirectSafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> Word32 -- ^ drawCount -> Word32 -- ^ stride -> IO () vkCmdDrawIndexedIndirectSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdDrawIndexedIndirect) {-# NOINLINE vkCmdDrawIndexedIndirectSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdDrawIndexedIndirect -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer buffer -- > , VkDeviceSize offset -- > , uint32_t drawCount -- > , uint32_t stride -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdDrawIndexedIndirect <- vkGetInstanceProc @VkCmdDrawIndexedIndirect vkInstance -- -- or less efficient: -- -- > myCmdDrawIndexedIndirect <- vkGetProc @VkCmdDrawIndexedIndirect -- -- __Note:__ @vkCmdDrawIndexedIndirectUnsafe@ and @vkCmdDrawIndexedIndirectSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdDrawIndexedIndirect@ is an alias -- of @vkCmdDrawIndexedIndirectUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdDrawIndexedIndirectSafe@. -- vkCmdDrawIndexedIndirect :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> Word32 -- ^ drawCount -> Word32 -- ^ stride -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdDrawIndexedIndirect = vkCmdDrawIndexedIndirectUnsafe #else vkCmdDrawIndexedIndirect = vkCmdDrawIndexedIndirectSafe #endif {-# INLINE vkCmdDrawIndexedIndirect #-} -- | Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdDrawIndexedIndirect -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer buffer -- > , VkDeviceSize offset -- > , uint32_t drawCount -- > , uint32_t stride -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect registry at www.khronos.org> type HS_vkCmdDrawIndexedIndirect = VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> Word32 -- ^ drawCount -> Word32 -- ^ stride -> IO () type PFN_vkCmdDrawIndexedIndirect = FunPtr HS_vkCmdDrawIndexedIndirect foreign import ccall unsafe "dynamic" unwrapVkCmdDrawIndexedIndirectUnsafe :: PFN_vkCmdDrawIndexedIndirect -> HS_vkCmdDrawIndexedIndirect foreign import ccall safe "dynamic" unwrapVkCmdDrawIndexedIndirectSafe :: PFN_vkCmdDrawIndexedIndirect -> HS_vkCmdDrawIndexedIndirect instance VulkanProc "vkCmdDrawIndexedIndirect" where type VkProcType "vkCmdDrawIndexedIndirect" = HS_vkCmdDrawIndexedIndirect vkProcSymbol = _VkCmdDrawIndexedIndirect {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdDrawIndexedIndirectUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdDrawIndexedIndirectSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdDispatch :: CString pattern VkCmdDispatch <- (is_VkCmdDispatch -> True) where VkCmdDispatch = _VkCmdDispatch {-# INLINE _VkCmdDispatch #-} _VkCmdDispatch :: CString _VkCmdDispatch = Ptr "vkCmdDispatch\NUL"# {-# INLINE is_VkCmdDispatch #-} is_VkCmdDispatch :: CString -> Bool is_VkCmdDispatch = (EQ ==) . cmpCStrings _VkCmdDispatch type VkCmdDispatch = "vkCmdDispatch" -- | -- Queues: 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @compute@ -- -- > void vkCmdDispatch -- > ( VkCommandBuffer commandBuffer -- > , uint32_t groupCountX -- > , uint32_t groupCountY -- > , uint32_t groupCountZ -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDispatch vkCmdDispatch registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdDispatch <- vkGetInstanceProc @VkCmdDispatch vkInstance -- -- or less efficient: -- -- > myCmdDispatch <- vkGetProc @VkCmdDispatch -- -- __Note:__ @vkCmdDispatchUnsafe@ and @vkCmdDispatchSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdDispatch@ is an alias -- of @vkCmdDispatchUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdDispatchSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdDispatch" vkCmdDispatchUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ groupCountX -> Word32 -- ^ groupCountY -> Word32 -- ^ groupCountZ -> IO () #else vkCmdDispatchUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ groupCountX -> Word32 -- ^ groupCountY -> Word32 -- ^ groupCountZ -> IO () vkCmdDispatchUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdDispatch) {-# NOINLINE vkCmdDispatchUnsafe #-} #endif -- | -- Queues: 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @compute@ -- -- > void vkCmdDispatch -- > ( VkCommandBuffer commandBuffer -- > , uint32_t groupCountX -- > , uint32_t groupCountY -- > , uint32_t groupCountZ -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDispatch vkCmdDispatch registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdDispatch <- vkGetInstanceProc @VkCmdDispatch vkInstance -- -- or less efficient: -- -- > myCmdDispatch <- vkGetProc @VkCmdDispatch -- -- __Note:__ @vkCmdDispatchUnsafe@ and @vkCmdDispatchSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdDispatch@ is an alias -- of @vkCmdDispatchUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdDispatchSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdDispatch" vkCmdDispatchSafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ groupCountX -> Word32 -- ^ groupCountY -> Word32 -- ^ groupCountZ -> IO () #else vkCmdDispatchSafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ groupCountX -> Word32 -- ^ groupCountY -> Word32 -- ^ groupCountZ -> IO () vkCmdDispatchSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdDispatch) {-# NOINLINE vkCmdDispatchSafe #-} #endif -- | -- Queues: 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @compute@ -- -- > void vkCmdDispatch -- > ( VkCommandBuffer commandBuffer -- > , uint32_t groupCountX -- > , uint32_t groupCountY -- > , uint32_t groupCountZ -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDispatch vkCmdDispatch registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdDispatch <- vkGetInstanceProc @VkCmdDispatch vkInstance -- -- or less efficient: -- -- > myCmdDispatch <- vkGetProc @VkCmdDispatch -- -- __Note:__ @vkCmdDispatchUnsafe@ and @vkCmdDispatchSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdDispatch@ is an alias -- of @vkCmdDispatchUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdDispatchSafe@. -- vkCmdDispatch :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ groupCountX -> Word32 -- ^ groupCountY -> Word32 -- ^ groupCountZ -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdDispatch = vkCmdDispatchUnsafe #else vkCmdDispatch = vkCmdDispatchSafe #endif {-# INLINE vkCmdDispatch #-} -- | Queues: 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @compute@ -- -- > void vkCmdDispatch -- > ( VkCommandBuffer commandBuffer -- > , uint32_t groupCountX -- > , uint32_t groupCountY -- > , uint32_t groupCountZ -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDispatch vkCmdDispatch registry at www.khronos.org> type HS_vkCmdDispatch = VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ groupCountX -> Word32 -- ^ groupCountY -> Word32 -- ^ groupCountZ -> IO () type PFN_vkCmdDispatch = FunPtr HS_vkCmdDispatch foreign import ccall unsafe "dynamic" unwrapVkCmdDispatchUnsafe :: PFN_vkCmdDispatch -> HS_vkCmdDispatch foreign import ccall safe "dynamic" unwrapVkCmdDispatchSafe :: PFN_vkCmdDispatch -> HS_vkCmdDispatch instance VulkanProc "vkCmdDispatch" where type VkProcType "vkCmdDispatch" = HS_vkCmdDispatch vkProcSymbol = _VkCmdDispatch {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdDispatchUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdDispatchSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdDispatchIndirect :: CString pattern VkCmdDispatchIndirect <- (is_VkCmdDispatchIndirect -> True) where VkCmdDispatchIndirect = _VkCmdDispatchIndirect {-# INLINE _VkCmdDispatchIndirect #-} _VkCmdDispatchIndirect :: CString _VkCmdDispatchIndirect = Ptr "vkCmdDispatchIndirect\NUL"# {-# INLINE is_VkCmdDispatchIndirect #-} is_VkCmdDispatchIndirect :: CString -> Bool is_VkCmdDispatchIndirect = (EQ ==) . cmpCStrings _VkCmdDispatchIndirect type VkCmdDispatchIndirect = "vkCmdDispatchIndirect" -- | -- Queues: 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @compute@ -- -- > void vkCmdDispatchIndirect -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer buffer -- > , VkDeviceSize offset -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDispatchIndirect vkCmdDispatchIndirect registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdDispatchIndirect <- vkGetInstanceProc @VkCmdDispatchIndirect vkInstance -- -- or less efficient: -- -- > myCmdDispatchIndirect <- vkGetProc @VkCmdDispatchIndirect -- -- __Note:__ @vkCmdDispatchIndirectUnsafe@ and @vkCmdDispatchIndirectSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdDispatchIndirect@ is an alias -- of @vkCmdDispatchIndirectUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdDispatchIndirectSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdDispatchIndirect" vkCmdDispatchIndirectUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> IO () #else vkCmdDispatchIndirectUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> IO () vkCmdDispatchIndirectUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdDispatchIndirect) {-# NOINLINE vkCmdDispatchIndirectUnsafe #-} #endif -- | -- Queues: 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @compute@ -- -- > void vkCmdDispatchIndirect -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer buffer -- > , VkDeviceSize offset -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDispatchIndirect vkCmdDispatchIndirect registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdDispatchIndirect <- vkGetInstanceProc @VkCmdDispatchIndirect vkInstance -- -- or less efficient: -- -- > myCmdDispatchIndirect <- vkGetProc @VkCmdDispatchIndirect -- -- __Note:__ @vkCmdDispatchIndirectUnsafe@ and @vkCmdDispatchIndirectSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdDispatchIndirect@ is an alias -- of @vkCmdDispatchIndirectUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdDispatchIndirectSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdDispatchIndirect" vkCmdDispatchIndirectSafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> IO () #else vkCmdDispatchIndirectSafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> IO () vkCmdDispatchIndirectSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdDispatchIndirect) {-# NOINLINE vkCmdDispatchIndirectSafe #-} #endif -- | -- Queues: 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @compute@ -- -- > void vkCmdDispatchIndirect -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer buffer -- > , VkDeviceSize offset -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDispatchIndirect vkCmdDispatchIndirect registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdDispatchIndirect <- vkGetInstanceProc @VkCmdDispatchIndirect vkInstance -- -- or less efficient: -- -- > myCmdDispatchIndirect <- vkGetProc @VkCmdDispatchIndirect -- -- __Note:__ @vkCmdDispatchIndirectUnsafe@ and @vkCmdDispatchIndirectSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdDispatchIndirect@ is an alias -- of @vkCmdDispatchIndirectUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdDispatchIndirectSafe@. -- vkCmdDispatchIndirect :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdDispatchIndirect = vkCmdDispatchIndirectUnsafe #else vkCmdDispatchIndirect = vkCmdDispatchIndirectSafe #endif {-# INLINE vkCmdDispatchIndirect #-} -- | Queues: 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @compute@ -- -- > void vkCmdDispatchIndirect -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer buffer -- > , VkDeviceSize offset -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdDispatchIndirect vkCmdDispatchIndirect registry at www.khronos.org> type HS_vkCmdDispatchIndirect = VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ buffer -> VkDeviceSize -- ^ offset -> IO () type PFN_vkCmdDispatchIndirect = FunPtr HS_vkCmdDispatchIndirect foreign import ccall unsafe "dynamic" unwrapVkCmdDispatchIndirectUnsafe :: PFN_vkCmdDispatchIndirect -> HS_vkCmdDispatchIndirect foreign import ccall safe "dynamic" unwrapVkCmdDispatchIndirectSafe :: PFN_vkCmdDispatchIndirect -> HS_vkCmdDispatchIndirect instance VulkanProc "vkCmdDispatchIndirect" where type VkProcType "vkCmdDispatchIndirect" = HS_vkCmdDispatchIndirect vkProcSymbol = _VkCmdDispatchIndirect {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdDispatchIndirectUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdDispatchIndirectSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdCopyBuffer :: CString pattern VkCmdCopyBuffer <- (is_VkCmdCopyBuffer -> True) where VkCmdCopyBuffer = _VkCmdCopyBuffer {-# INLINE _VkCmdCopyBuffer #-} _VkCmdCopyBuffer :: CString _VkCmdCopyBuffer = Ptr "vkCmdCopyBuffer\NUL"# {-# INLINE is_VkCmdCopyBuffer #-} is_VkCmdCopyBuffer :: CString -> Bool is_VkCmdCopyBuffer = (EQ ==) . cmpCStrings _VkCmdCopyBuffer type VkCmdCopyBuffer = "vkCmdCopyBuffer" -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer srcBuffer -- > , VkBuffer dstBuffer -- > , uint32_t regionCount -- > , const VkBufferCopy* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyBuffer vkCmdCopyBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdCopyBuffer <- vkGetInstanceProc @VkCmdCopyBuffer vkInstance -- -- or less efficient: -- -- > myCmdCopyBuffer <- vkGetProc @VkCmdCopyBuffer -- -- __Note:__ @vkCmdCopyBufferUnsafe@ and @vkCmdCopyBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdCopyBuffer@ is an alias -- of @vkCmdCopyBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdCopyBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdCopyBuffer" vkCmdCopyBufferUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ srcBuffer -> VkBuffer -- ^ dstBuffer -> Word32 -- ^ regionCount -> Ptr VkBufferCopy -- ^ pRegions -> IO () #else vkCmdCopyBufferUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ srcBuffer -> VkBuffer -- ^ dstBuffer -> Word32 -- ^ regionCount -> Ptr VkBufferCopy -- ^ pRegions -> IO () vkCmdCopyBufferUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdCopyBuffer) {-# NOINLINE vkCmdCopyBufferUnsafe #-} #endif -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer srcBuffer -- > , VkBuffer dstBuffer -- > , uint32_t regionCount -- > , const VkBufferCopy* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyBuffer vkCmdCopyBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdCopyBuffer <- vkGetInstanceProc @VkCmdCopyBuffer vkInstance -- -- or less efficient: -- -- > myCmdCopyBuffer <- vkGetProc @VkCmdCopyBuffer -- -- __Note:__ @vkCmdCopyBufferUnsafe@ and @vkCmdCopyBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdCopyBuffer@ is an alias -- of @vkCmdCopyBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdCopyBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdCopyBuffer" vkCmdCopyBufferSafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ srcBuffer -> VkBuffer -- ^ dstBuffer -> Word32 -- ^ regionCount -> Ptr VkBufferCopy -- ^ pRegions -> IO () #else vkCmdCopyBufferSafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ srcBuffer -> VkBuffer -- ^ dstBuffer -> Word32 -- ^ regionCount -> Ptr VkBufferCopy -- ^ pRegions -> IO () vkCmdCopyBufferSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdCopyBuffer) {-# NOINLINE vkCmdCopyBufferSafe #-} #endif -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer srcBuffer -- > , VkBuffer dstBuffer -- > , uint32_t regionCount -- > , const VkBufferCopy* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyBuffer vkCmdCopyBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdCopyBuffer <- vkGetInstanceProc @VkCmdCopyBuffer vkInstance -- -- or less efficient: -- -- > myCmdCopyBuffer <- vkGetProc @VkCmdCopyBuffer -- -- __Note:__ @vkCmdCopyBufferUnsafe@ and @vkCmdCopyBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdCopyBuffer@ is an alias -- of @vkCmdCopyBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdCopyBufferSafe@. -- vkCmdCopyBuffer :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ srcBuffer -> VkBuffer -- ^ dstBuffer -> Word32 -- ^ regionCount -> Ptr VkBufferCopy -- ^ pRegions -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdCopyBuffer = vkCmdCopyBufferUnsafe #else vkCmdCopyBuffer = vkCmdCopyBufferSafe #endif {-# INLINE vkCmdCopyBuffer #-} -- | Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer srcBuffer -- > , VkBuffer dstBuffer -- > , uint32_t regionCount -- > , const VkBufferCopy* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyBuffer vkCmdCopyBuffer registry at www.khronos.org> type HS_vkCmdCopyBuffer = VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ srcBuffer -> VkBuffer -- ^ dstBuffer -> Word32 -- ^ regionCount -> Ptr VkBufferCopy -- ^ pRegions -> IO () type PFN_vkCmdCopyBuffer = FunPtr HS_vkCmdCopyBuffer foreign import ccall unsafe "dynamic" unwrapVkCmdCopyBufferUnsafe :: PFN_vkCmdCopyBuffer -> HS_vkCmdCopyBuffer foreign import ccall safe "dynamic" unwrapVkCmdCopyBufferSafe :: PFN_vkCmdCopyBuffer -> HS_vkCmdCopyBuffer instance VulkanProc "vkCmdCopyBuffer" where type VkProcType "vkCmdCopyBuffer" = HS_vkCmdCopyBuffer vkProcSymbol = _VkCmdCopyBuffer {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdCopyBufferUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdCopyBufferSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdCopyImage :: CString pattern VkCmdCopyImage <- (is_VkCmdCopyImage -> True) where VkCmdCopyImage = _VkCmdCopyImage {-# INLINE _VkCmdCopyImage #-} _VkCmdCopyImage :: CString _VkCmdCopyImage = Ptr "vkCmdCopyImage\NUL"# {-# INLINE is_VkCmdCopyImage #-} is_VkCmdCopyImage :: CString -> Bool is_VkCmdCopyImage = (EQ ==) . cmpCStrings _VkCmdCopyImage type VkCmdCopyImage = "vkCmdCopyImage" -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage srcImage -- > , VkImageLayout srcImageLayout -- > , VkImage dstImage -- > , VkImageLayout dstImageLayout -- > , uint32_t regionCount -- > , const VkImageCopy* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyImage vkCmdCopyImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdCopyImage <- vkGetInstanceProc @VkCmdCopyImage vkInstance -- -- or less efficient: -- -- > myCmdCopyImage <- vkGetProc @VkCmdCopyImage -- -- __Note:__ @vkCmdCopyImageUnsafe@ and @vkCmdCopyImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdCopyImage@ is an alias -- of @vkCmdCopyImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdCopyImageSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdCopyImage" vkCmdCopyImageUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkImageCopy -- ^ pRegions -> IO () #else vkCmdCopyImageUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkImageCopy -- ^ pRegions -> IO () vkCmdCopyImageUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdCopyImage) {-# NOINLINE vkCmdCopyImageUnsafe #-} #endif -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage srcImage -- > , VkImageLayout srcImageLayout -- > , VkImage dstImage -- > , VkImageLayout dstImageLayout -- > , uint32_t regionCount -- > , const VkImageCopy* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyImage vkCmdCopyImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdCopyImage <- vkGetInstanceProc @VkCmdCopyImage vkInstance -- -- or less efficient: -- -- > myCmdCopyImage <- vkGetProc @VkCmdCopyImage -- -- __Note:__ @vkCmdCopyImageUnsafe@ and @vkCmdCopyImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdCopyImage@ is an alias -- of @vkCmdCopyImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdCopyImageSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdCopyImage" vkCmdCopyImageSafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkImageCopy -- ^ pRegions -> IO () #else vkCmdCopyImageSafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkImageCopy -- ^ pRegions -> IO () vkCmdCopyImageSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdCopyImage) {-# NOINLINE vkCmdCopyImageSafe #-} #endif -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage srcImage -- > , VkImageLayout srcImageLayout -- > , VkImage dstImage -- > , VkImageLayout dstImageLayout -- > , uint32_t regionCount -- > , const VkImageCopy* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyImage vkCmdCopyImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdCopyImage <- vkGetInstanceProc @VkCmdCopyImage vkInstance -- -- or less efficient: -- -- > myCmdCopyImage <- vkGetProc @VkCmdCopyImage -- -- __Note:__ @vkCmdCopyImageUnsafe@ and @vkCmdCopyImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdCopyImage@ is an alias -- of @vkCmdCopyImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdCopyImageSafe@. -- vkCmdCopyImage :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkImageCopy -- ^ pRegions -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdCopyImage = vkCmdCopyImageUnsafe #else vkCmdCopyImage = vkCmdCopyImageSafe #endif {-# INLINE vkCmdCopyImage #-} -- | Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage srcImage -- > , VkImageLayout srcImageLayout -- > , VkImage dstImage -- > , VkImageLayout dstImageLayout -- > , uint32_t regionCount -- > , const VkImageCopy* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyImage vkCmdCopyImage registry at www.khronos.org> type HS_vkCmdCopyImage = VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkImageCopy -- ^ pRegions -> IO () type PFN_vkCmdCopyImage = FunPtr HS_vkCmdCopyImage foreign import ccall unsafe "dynamic" unwrapVkCmdCopyImageUnsafe :: PFN_vkCmdCopyImage -> HS_vkCmdCopyImage foreign import ccall safe "dynamic" unwrapVkCmdCopyImageSafe :: PFN_vkCmdCopyImage -> HS_vkCmdCopyImage instance VulkanProc "vkCmdCopyImage" where type VkProcType "vkCmdCopyImage" = HS_vkCmdCopyImage vkProcSymbol = _VkCmdCopyImage {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdCopyImageUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdCopyImageSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdBlitImage :: CString pattern VkCmdBlitImage <- (is_VkCmdBlitImage -> True) where VkCmdBlitImage = _VkCmdBlitImage {-# INLINE _VkCmdBlitImage #-} _VkCmdBlitImage :: CString _VkCmdBlitImage = Ptr "vkCmdBlitImage\NUL"# {-# INLINE is_VkCmdBlitImage #-} is_VkCmdBlitImage :: CString -> Bool is_VkCmdBlitImage = (EQ ==) . cmpCStrings _VkCmdBlitImage type VkCmdBlitImage = "vkCmdBlitImage" -- | -- Queues: 'graphics'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdBlitImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage srcImage -- > , VkImageLayout srcImageLayout -- > , VkImage dstImage -- > , VkImageLayout dstImageLayout -- > , uint32_t regionCount -- > , const VkImageBlit* pRegions -- > , VkFilter filter -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBlitImage vkCmdBlitImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBlitImage <- vkGetInstanceProc @VkCmdBlitImage vkInstance -- -- or less efficient: -- -- > myCmdBlitImage <- vkGetProc @VkCmdBlitImage -- -- __Note:__ @vkCmdBlitImageUnsafe@ and @vkCmdBlitImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBlitImage@ is an alias -- of @vkCmdBlitImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBlitImageSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdBlitImage" vkCmdBlitImageUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkImageBlit -- ^ pRegions -> VkFilter -- ^ filter -> IO () #else vkCmdBlitImageUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkImageBlit -- ^ pRegions -> VkFilter -- ^ filter -> IO () vkCmdBlitImageUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdBlitImage) {-# NOINLINE vkCmdBlitImageUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdBlitImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage srcImage -- > , VkImageLayout srcImageLayout -- > , VkImage dstImage -- > , VkImageLayout dstImageLayout -- > , uint32_t regionCount -- > , const VkImageBlit* pRegions -- > , VkFilter filter -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBlitImage vkCmdBlitImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBlitImage <- vkGetInstanceProc @VkCmdBlitImage vkInstance -- -- or less efficient: -- -- > myCmdBlitImage <- vkGetProc @VkCmdBlitImage -- -- __Note:__ @vkCmdBlitImageUnsafe@ and @vkCmdBlitImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBlitImage@ is an alias -- of @vkCmdBlitImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBlitImageSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdBlitImage" vkCmdBlitImageSafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkImageBlit -- ^ pRegions -> VkFilter -- ^ filter -> IO () #else vkCmdBlitImageSafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkImageBlit -- ^ pRegions -> VkFilter -- ^ filter -> IO () vkCmdBlitImageSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdBlitImage) {-# NOINLINE vkCmdBlitImageSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdBlitImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage srcImage -- > , VkImageLayout srcImageLayout -- > , VkImage dstImage -- > , VkImageLayout dstImageLayout -- > , uint32_t regionCount -- > , const VkImageBlit* pRegions -- > , VkFilter filter -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBlitImage vkCmdBlitImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBlitImage <- vkGetInstanceProc @VkCmdBlitImage vkInstance -- -- or less efficient: -- -- > myCmdBlitImage <- vkGetProc @VkCmdBlitImage -- -- __Note:__ @vkCmdBlitImageUnsafe@ and @vkCmdBlitImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBlitImage@ is an alias -- of @vkCmdBlitImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBlitImageSafe@. -- vkCmdBlitImage :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkImageBlit -- ^ pRegions -> VkFilter -- ^ filter -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdBlitImage = vkCmdBlitImageUnsafe #else vkCmdBlitImage = vkCmdBlitImageSafe #endif {-# INLINE vkCmdBlitImage #-} -- | Queues: 'graphics'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdBlitImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage srcImage -- > , VkImageLayout srcImageLayout -- > , VkImage dstImage -- > , VkImageLayout dstImageLayout -- > , uint32_t regionCount -- > , const VkImageBlit* pRegions -- > , VkFilter filter -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBlitImage vkCmdBlitImage registry at www.khronos.org> type HS_vkCmdBlitImage = VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkImageBlit -- ^ pRegions -> VkFilter -- ^ filter -> IO () type PFN_vkCmdBlitImage = FunPtr HS_vkCmdBlitImage foreign import ccall unsafe "dynamic" unwrapVkCmdBlitImageUnsafe :: PFN_vkCmdBlitImage -> HS_vkCmdBlitImage foreign import ccall safe "dynamic" unwrapVkCmdBlitImageSafe :: PFN_vkCmdBlitImage -> HS_vkCmdBlitImage instance VulkanProc "vkCmdBlitImage" where type VkProcType "vkCmdBlitImage" = HS_vkCmdBlitImage vkProcSymbol = _VkCmdBlitImage {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdBlitImageUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdBlitImageSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdCopyBufferToImage :: CString pattern VkCmdCopyBufferToImage <- (is_VkCmdCopyBufferToImage -> True) where VkCmdCopyBufferToImage = _VkCmdCopyBufferToImage {-# INLINE _VkCmdCopyBufferToImage #-} _VkCmdCopyBufferToImage :: CString _VkCmdCopyBufferToImage = Ptr "vkCmdCopyBufferToImage\NUL"# {-# INLINE is_VkCmdCopyBufferToImage #-} is_VkCmdCopyBufferToImage :: CString -> Bool is_VkCmdCopyBufferToImage = (EQ ==) . cmpCStrings _VkCmdCopyBufferToImage type VkCmdCopyBufferToImage = "vkCmdCopyBufferToImage" -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyBufferToImage -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer srcBuffer -- > , VkImage dstImage -- > , VkImageLayout dstImageLayout -- > , uint32_t regionCount -- > , const VkBufferImageCopy* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyBufferToImage vkCmdCopyBufferToImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdCopyBufferToImage <- vkGetInstanceProc @VkCmdCopyBufferToImage vkInstance -- -- or less efficient: -- -- > myCmdCopyBufferToImage <- vkGetProc @VkCmdCopyBufferToImage -- -- __Note:__ @vkCmdCopyBufferToImageUnsafe@ and @vkCmdCopyBufferToImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdCopyBufferToImage@ is an alias -- of @vkCmdCopyBufferToImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdCopyBufferToImageSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdCopyBufferToImage" vkCmdCopyBufferToImageUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ srcBuffer -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkBufferImageCopy -- ^ pRegions -> IO () #else vkCmdCopyBufferToImageUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ srcBuffer -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkBufferImageCopy -- ^ pRegions -> IO () vkCmdCopyBufferToImageUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdCopyBufferToImage) {-# NOINLINE vkCmdCopyBufferToImageUnsafe #-} #endif -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyBufferToImage -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer srcBuffer -- > , VkImage dstImage -- > , VkImageLayout dstImageLayout -- > , uint32_t regionCount -- > , const VkBufferImageCopy* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyBufferToImage vkCmdCopyBufferToImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdCopyBufferToImage <- vkGetInstanceProc @VkCmdCopyBufferToImage vkInstance -- -- or less efficient: -- -- > myCmdCopyBufferToImage <- vkGetProc @VkCmdCopyBufferToImage -- -- __Note:__ @vkCmdCopyBufferToImageUnsafe@ and @vkCmdCopyBufferToImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdCopyBufferToImage@ is an alias -- of @vkCmdCopyBufferToImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdCopyBufferToImageSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdCopyBufferToImage" vkCmdCopyBufferToImageSafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ srcBuffer -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkBufferImageCopy -- ^ pRegions -> IO () #else vkCmdCopyBufferToImageSafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ srcBuffer -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkBufferImageCopy -- ^ pRegions -> IO () vkCmdCopyBufferToImageSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdCopyBufferToImage) {-# NOINLINE vkCmdCopyBufferToImageSafe #-} #endif -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyBufferToImage -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer srcBuffer -- > , VkImage dstImage -- > , VkImageLayout dstImageLayout -- > , uint32_t regionCount -- > , const VkBufferImageCopy* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyBufferToImage vkCmdCopyBufferToImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdCopyBufferToImage <- vkGetInstanceProc @VkCmdCopyBufferToImage vkInstance -- -- or less efficient: -- -- > myCmdCopyBufferToImage <- vkGetProc @VkCmdCopyBufferToImage -- -- __Note:__ @vkCmdCopyBufferToImageUnsafe@ and @vkCmdCopyBufferToImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdCopyBufferToImage@ is an alias -- of @vkCmdCopyBufferToImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdCopyBufferToImageSafe@. -- vkCmdCopyBufferToImage :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ srcBuffer -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkBufferImageCopy -- ^ pRegions -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdCopyBufferToImage = vkCmdCopyBufferToImageUnsafe #else vkCmdCopyBufferToImage = vkCmdCopyBufferToImageSafe #endif {-# INLINE vkCmdCopyBufferToImage #-} -- | Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyBufferToImage -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer srcBuffer -- > , VkImage dstImage -- > , VkImageLayout dstImageLayout -- > , uint32_t regionCount -- > , const VkBufferImageCopy* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyBufferToImage vkCmdCopyBufferToImage registry at www.khronos.org> type HS_vkCmdCopyBufferToImage = VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ srcBuffer -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkBufferImageCopy -- ^ pRegions -> IO () type PFN_vkCmdCopyBufferToImage = FunPtr HS_vkCmdCopyBufferToImage foreign import ccall unsafe "dynamic" unwrapVkCmdCopyBufferToImageUnsafe :: PFN_vkCmdCopyBufferToImage -> HS_vkCmdCopyBufferToImage foreign import ccall safe "dynamic" unwrapVkCmdCopyBufferToImageSafe :: PFN_vkCmdCopyBufferToImage -> HS_vkCmdCopyBufferToImage instance VulkanProc "vkCmdCopyBufferToImage" where type VkProcType "vkCmdCopyBufferToImage" = HS_vkCmdCopyBufferToImage vkProcSymbol = _VkCmdCopyBufferToImage {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdCopyBufferToImageUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdCopyBufferToImageSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdCopyImageToBuffer :: CString pattern VkCmdCopyImageToBuffer <- (is_VkCmdCopyImageToBuffer -> True) where VkCmdCopyImageToBuffer = _VkCmdCopyImageToBuffer {-# INLINE _VkCmdCopyImageToBuffer #-} _VkCmdCopyImageToBuffer :: CString _VkCmdCopyImageToBuffer = Ptr "vkCmdCopyImageToBuffer\NUL"# {-# INLINE is_VkCmdCopyImageToBuffer #-} is_VkCmdCopyImageToBuffer :: CString -> Bool is_VkCmdCopyImageToBuffer = (EQ ==) . cmpCStrings _VkCmdCopyImageToBuffer type VkCmdCopyImageToBuffer = "vkCmdCopyImageToBuffer" -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyImageToBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkImage srcImage -- > , VkImageLayout srcImageLayout -- > , VkBuffer dstBuffer -- > , uint32_t regionCount -- > , const VkBufferImageCopy* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdCopyImageToBuffer <- vkGetInstanceProc @VkCmdCopyImageToBuffer vkInstance -- -- or less efficient: -- -- > myCmdCopyImageToBuffer <- vkGetProc @VkCmdCopyImageToBuffer -- -- __Note:__ @vkCmdCopyImageToBufferUnsafe@ and @vkCmdCopyImageToBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdCopyImageToBuffer@ is an alias -- of @vkCmdCopyImageToBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdCopyImageToBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdCopyImageToBuffer" vkCmdCopyImageToBufferUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkBuffer -- ^ dstBuffer -> Word32 -- ^ regionCount -> Ptr VkBufferImageCopy -- ^ pRegions -> IO () #else vkCmdCopyImageToBufferUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkBuffer -- ^ dstBuffer -> Word32 -- ^ regionCount -> Ptr VkBufferImageCopy -- ^ pRegions -> IO () vkCmdCopyImageToBufferUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdCopyImageToBuffer) {-# NOINLINE vkCmdCopyImageToBufferUnsafe #-} #endif -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyImageToBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkImage srcImage -- > , VkImageLayout srcImageLayout -- > , VkBuffer dstBuffer -- > , uint32_t regionCount -- > , const VkBufferImageCopy* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdCopyImageToBuffer <- vkGetInstanceProc @VkCmdCopyImageToBuffer vkInstance -- -- or less efficient: -- -- > myCmdCopyImageToBuffer <- vkGetProc @VkCmdCopyImageToBuffer -- -- __Note:__ @vkCmdCopyImageToBufferUnsafe@ and @vkCmdCopyImageToBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdCopyImageToBuffer@ is an alias -- of @vkCmdCopyImageToBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdCopyImageToBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdCopyImageToBuffer" vkCmdCopyImageToBufferSafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkBuffer -- ^ dstBuffer -> Word32 -- ^ regionCount -> Ptr VkBufferImageCopy -- ^ pRegions -> IO () #else vkCmdCopyImageToBufferSafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkBuffer -- ^ dstBuffer -> Word32 -- ^ regionCount -> Ptr VkBufferImageCopy -- ^ pRegions -> IO () vkCmdCopyImageToBufferSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdCopyImageToBuffer) {-# NOINLINE vkCmdCopyImageToBufferSafe #-} #endif -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyImageToBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkImage srcImage -- > , VkImageLayout srcImageLayout -- > , VkBuffer dstBuffer -- > , uint32_t regionCount -- > , const VkBufferImageCopy* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdCopyImageToBuffer <- vkGetInstanceProc @VkCmdCopyImageToBuffer vkInstance -- -- or less efficient: -- -- > myCmdCopyImageToBuffer <- vkGetProc @VkCmdCopyImageToBuffer -- -- __Note:__ @vkCmdCopyImageToBufferUnsafe@ and @vkCmdCopyImageToBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdCopyImageToBuffer@ is an alias -- of @vkCmdCopyImageToBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdCopyImageToBufferSafe@. -- vkCmdCopyImageToBuffer :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkBuffer -- ^ dstBuffer -> Word32 -- ^ regionCount -> Ptr VkBufferImageCopy -- ^ pRegions -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdCopyImageToBuffer = vkCmdCopyImageToBufferUnsafe #else vkCmdCopyImageToBuffer = vkCmdCopyImageToBufferSafe #endif {-# INLINE vkCmdCopyImageToBuffer #-} -- | Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyImageToBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkImage srcImage -- > , VkImageLayout srcImageLayout -- > , VkBuffer dstBuffer -- > , uint32_t regionCount -- > , const VkBufferImageCopy* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer registry at www.khronos.org> type HS_vkCmdCopyImageToBuffer = VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkBuffer -- ^ dstBuffer -> Word32 -- ^ regionCount -> Ptr VkBufferImageCopy -- ^ pRegions -> IO () type PFN_vkCmdCopyImageToBuffer = FunPtr HS_vkCmdCopyImageToBuffer foreign import ccall unsafe "dynamic" unwrapVkCmdCopyImageToBufferUnsafe :: PFN_vkCmdCopyImageToBuffer -> HS_vkCmdCopyImageToBuffer foreign import ccall safe "dynamic" unwrapVkCmdCopyImageToBufferSafe :: PFN_vkCmdCopyImageToBuffer -> HS_vkCmdCopyImageToBuffer instance VulkanProc "vkCmdCopyImageToBuffer" where type VkProcType "vkCmdCopyImageToBuffer" = HS_vkCmdCopyImageToBuffer vkProcSymbol = _VkCmdCopyImageToBuffer {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdCopyImageToBufferUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdCopyImageToBufferSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdUpdateBuffer :: CString pattern VkCmdUpdateBuffer <- (is_VkCmdUpdateBuffer -> True) where VkCmdUpdateBuffer = _VkCmdUpdateBuffer {-# INLINE _VkCmdUpdateBuffer #-} _VkCmdUpdateBuffer :: CString _VkCmdUpdateBuffer = Ptr "vkCmdUpdateBuffer\NUL"# {-# INLINE is_VkCmdUpdateBuffer #-} is_VkCmdUpdateBuffer :: CString -> Bool is_VkCmdUpdateBuffer = (EQ ==) . cmpCStrings _VkCmdUpdateBuffer type VkCmdUpdateBuffer = "vkCmdUpdateBuffer" -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdUpdateBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer dstBuffer -- > , VkDeviceSize dstOffset -- > , VkDeviceSize dataSize -- > , const void* pData -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdUpdateBuffer vkCmdUpdateBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdUpdateBuffer <- vkGetInstanceProc @VkCmdUpdateBuffer vkInstance -- -- or less efficient: -- -- > myCmdUpdateBuffer <- vkGetProc @VkCmdUpdateBuffer -- -- __Note:__ @vkCmdUpdateBufferUnsafe@ and @vkCmdUpdateBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdUpdateBuffer@ is an alias -- of @vkCmdUpdateBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdUpdateBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdUpdateBuffer" vkCmdUpdateBufferUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ dstBuffer -> VkDeviceSize -- ^ dstOffset -> VkDeviceSize -- ^ dataSize -> Ptr Void -- ^ pData -> IO () #else vkCmdUpdateBufferUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ dstBuffer -> VkDeviceSize -- ^ dstOffset -> VkDeviceSize -- ^ dataSize -> Ptr Void -- ^ pData -> IO () vkCmdUpdateBufferUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdUpdateBuffer) {-# NOINLINE vkCmdUpdateBufferUnsafe #-} #endif -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdUpdateBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer dstBuffer -- > , VkDeviceSize dstOffset -- > , VkDeviceSize dataSize -- > , const void* pData -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdUpdateBuffer vkCmdUpdateBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdUpdateBuffer <- vkGetInstanceProc @VkCmdUpdateBuffer vkInstance -- -- or less efficient: -- -- > myCmdUpdateBuffer <- vkGetProc @VkCmdUpdateBuffer -- -- __Note:__ @vkCmdUpdateBufferUnsafe@ and @vkCmdUpdateBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdUpdateBuffer@ is an alias -- of @vkCmdUpdateBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdUpdateBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdUpdateBuffer" vkCmdUpdateBufferSafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ dstBuffer -> VkDeviceSize -- ^ dstOffset -> VkDeviceSize -- ^ dataSize -> Ptr Void -- ^ pData -> IO () #else vkCmdUpdateBufferSafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ dstBuffer -> VkDeviceSize -- ^ dstOffset -> VkDeviceSize -- ^ dataSize -> Ptr Void -- ^ pData -> IO () vkCmdUpdateBufferSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdUpdateBuffer) {-# NOINLINE vkCmdUpdateBufferSafe #-} #endif -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdUpdateBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer dstBuffer -- > , VkDeviceSize dstOffset -- > , VkDeviceSize dataSize -- > , const void* pData -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdUpdateBuffer vkCmdUpdateBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdUpdateBuffer <- vkGetInstanceProc @VkCmdUpdateBuffer vkInstance -- -- or less efficient: -- -- > myCmdUpdateBuffer <- vkGetProc @VkCmdUpdateBuffer -- -- __Note:__ @vkCmdUpdateBufferUnsafe@ and @vkCmdUpdateBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdUpdateBuffer@ is an alias -- of @vkCmdUpdateBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdUpdateBufferSafe@. -- vkCmdUpdateBuffer :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ dstBuffer -> VkDeviceSize -- ^ dstOffset -> VkDeviceSize -- ^ dataSize -> Ptr Void -- ^ pData -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdUpdateBuffer = vkCmdUpdateBufferUnsafe #else vkCmdUpdateBuffer = vkCmdUpdateBufferSafe #endif {-# INLINE vkCmdUpdateBuffer #-} -- | Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdUpdateBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer dstBuffer -- > , VkDeviceSize dstOffset -- > , VkDeviceSize dataSize -- > , const void* pData -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdUpdateBuffer vkCmdUpdateBuffer registry at www.khronos.org> type HS_vkCmdUpdateBuffer = VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ dstBuffer -> VkDeviceSize -- ^ dstOffset -> VkDeviceSize -- ^ dataSize -> Ptr Void -- ^ pData -> IO () type PFN_vkCmdUpdateBuffer = FunPtr HS_vkCmdUpdateBuffer foreign import ccall unsafe "dynamic" unwrapVkCmdUpdateBufferUnsafe :: PFN_vkCmdUpdateBuffer -> HS_vkCmdUpdateBuffer foreign import ccall safe "dynamic" unwrapVkCmdUpdateBufferSafe :: PFN_vkCmdUpdateBuffer -> HS_vkCmdUpdateBuffer instance VulkanProc "vkCmdUpdateBuffer" where type VkProcType "vkCmdUpdateBuffer" = HS_vkCmdUpdateBuffer vkProcSymbol = _VkCmdUpdateBuffer {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdUpdateBufferUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdUpdateBufferSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdFillBuffer :: CString pattern VkCmdFillBuffer <- (is_VkCmdFillBuffer -> True) where VkCmdFillBuffer = _VkCmdFillBuffer {-# INLINE _VkCmdFillBuffer #-} _VkCmdFillBuffer :: CString _VkCmdFillBuffer = Ptr "vkCmdFillBuffer\NUL"# {-# INLINE is_VkCmdFillBuffer #-} is_VkCmdFillBuffer :: CString -> Bool is_VkCmdFillBuffer = (EQ ==) . cmpCStrings _VkCmdFillBuffer type VkCmdFillBuffer = "vkCmdFillBuffer" -- | -- transfer support is only available when VK_KHR_maintenance1 is enabled, as documented in valid usage language in the specification -- -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdFillBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer dstBuffer -- > , VkDeviceSize dstOffset -- > , VkDeviceSize size -- > , uint32_t data -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdFillBuffer vkCmdFillBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdFillBuffer <- vkGetInstanceProc @VkCmdFillBuffer vkInstance -- -- or less efficient: -- -- > myCmdFillBuffer <- vkGetProc @VkCmdFillBuffer -- -- __Note:__ @vkCmdFillBufferUnsafe@ and @vkCmdFillBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdFillBuffer@ is an alias -- of @vkCmdFillBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdFillBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdFillBuffer" vkCmdFillBufferUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ dstBuffer -> VkDeviceSize -- ^ dstOffset -> VkDeviceSize -- ^ size -> Word32 -- ^ data -> IO () #else vkCmdFillBufferUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ dstBuffer -> VkDeviceSize -- ^ dstOffset -> VkDeviceSize -- ^ size -> Word32 -- ^ data -> IO () vkCmdFillBufferUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdFillBuffer) {-# NOINLINE vkCmdFillBufferUnsafe #-} #endif -- | -- transfer support is only available when VK_KHR_maintenance1 is enabled, as documented in valid usage language in the specification -- -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdFillBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer dstBuffer -- > , VkDeviceSize dstOffset -- > , VkDeviceSize size -- > , uint32_t data -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdFillBuffer vkCmdFillBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdFillBuffer <- vkGetInstanceProc @VkCmdFillBuffer vkInstance -- -- or less efficient: -- -- > myCmdFillBuffer <- vkGetProc @VkCmdFillBuffer -- -- __Note:__ @vkCmdFillBufferUnsafe@ and @vkCmdFillBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdFillBuffer@ is an alias -- of @vkCmdFillBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdFillBufferSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdFillBuffer" vkCmdFillBufferSafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ dstBuffer -> VkDeviceSize -- ^ dstOffset -> VkDeviceSize -- ^ size -> Word32 -- ^ data -> IO () #else vkCmdFillBufferSafe :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ dstBuffer -> VkDeviceSize -- ^ dstOffset -> VkDeviceSize -- ^ size -> Word32 -- ^ data -> IO () vkCmdFillBufferSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdFillBuffer) {-# NOINLINE vkCmdFillBufferSafe #-} #endif -- | -- transfer support is only available when VK_KHR_maintenance1 is enabled, as documented in valid usage language in the specification -- -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdFillBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer dstBuffer -- > , VkDeviceSize dstOffset -- > , VkDeviceSize size -- > , uint32_t data -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdFillBuffer vkCmdFillBuffer registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdFillBuffer <- vkGetInstanceProc @VkCmdFillBuffer vkInstance -- -- or less efficient: -- -- > myCmdFillBuffer <- vkGetProc @VkCmdFillBuffer -- -- __Note:__ @vkCmdFillBufferUnsafe@ and @vkCmdFillBufferSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdFillBuffer@ is an alias -- of @vkCmdFillBufferUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdFillBufferSafe@. -- vkCmdFillBuffer :: VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ dstBuffer -> VkDeviceSize -- ^ dstOffset -> VkDeviceSize -- ^ size -> Word32 -- ^ data -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdFillBuffer = vkCmdFillBufferUnsafe #else vkCmdFillBuffer = vkCmdFillBufferSafe #endif {-# INLINE vkCmdFillBuffer #-} -- | transfer support is only available when VK_KHR_maintenance1 is enabled, as documented in valid usage language in the specification -- -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdFillBuffer -- > ( VkCommandBuffer commandBuffer -- > , VkBuffer dstBuffer -- > , VkDeviceSize dstOffset -- > , VkDeviceSize size -- > , uint32_t data -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdFillBuffer vkCmdFillBuffer registry at www.khronos.org> type HS_vkCmdFillBuffer = VkCommandBuffer -- ^ commandBuffer -> VkBuffer -- ^ dstBuffer -> VkDeviceSize -- ^ dstOffset -> VkDeviceSize -- ^ size -> Word32 -- ^ data -> IO () type PFN_vkCmdFillBuffer = FunPtr HS_vkCmdFillBuffer foreign import ccall unsafe "dynamic" unwrapVkCmdFillBufferUnsafe :: PFN_vkCmdFillBuffer -> HS_vkCmdFillBuffer foreign import ccall safe "dynamic" unwrapVkCmdFillBufferSafe :: PFN_vkCmdFillBuffer -> HS_vkCmdFillBuffer instance VulkanProc "vkCmdFillBuffer" where type VkProcType "vkCmdFillBuffer" = HS_vkCmdFillBuffer vkProcSymbol = _VkCmdFillBuffer {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdFillBufferUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdFillBufferSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdClearColorImage :: CString pattern VkCmdClearColorImage <- (is_VkCmdClearColorImage -> True) where VkCmdClearColorImage = _VkCmdClearColorImage {-# INLINE _VkCmdClearColorImage #-} _VkCmdClearColorImage :: CString _VkCmdClearColorImage = Ptr "vkCmdClearColorImage\NUL"# {-# INLINE is_VkCmdClearColorImage #-} is_VkCmdClearColorImage :: CString -> Bool is_VkCmdClearColorImage = (EQ ==) . cmpCStrings _VkCmdClearColorImage type VkCmdClearColorImage = "vkCmdClearColorImage" -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdClearColorImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage image -- > , VkImageLayout imageLayout -- > , const VkClearColorValue* pColor -- > , uint32_t rangeCount -- > , const VkImageSubresourceRange* pRanges -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdClearColorImage vkCmdClearColorImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdClearColorImage <- vkGetInstanceProc @VkCmdClearColorImage vkInstance -- -- or less efficient: -- -- > myCmdClearColorImage <- vkGetProc @VkCmdClearColorImage -- -- __Note:__ @vkCmdClearColorImageUnsafe@ and @vkCmdClearColorImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdClearColorImage@ is an alias -- of @vkCmdClearColorImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdClearColorImageSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdClearColorImage" vkCmdClearColorImageUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ image -> VkImageLayout -- ^ imageLayout -> Ptr VkClearColorValue -- ^ pColor -> Word32 -- ^ rangeCount -> Ptr VkImageSubresourceRange -- ^ pRanges -> IO () #else vkCmdClearColorImageUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ image -> VkImageLayout -- ^ imageLayout -> Ptr VkClearColorValue -- ^ pColor -> Word32 -- ^ rangeCount -> Ptr VkImageSubresourceRange -- ^ pRanges -> IO () vkCmdClearColorImageUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdClearColorImage) {-# NOINLINE vkCmdClearColorImageUnsafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdClearColorImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage image -- > , VkImageLayout imageLayout -- > , const VkClearColorValue* pColor -- > , uint32_t rangeCount -- > , const VkImageSubresourceRange* pRanges -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdClearColorImage vkCmdClearColorImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdClearColorImage <- vkGetInstanceProc @VkCmdClearColorImage vkInstance -- -- or less efficient: -- -- > myCmdClearColorImage <- vkGetProc @VkCmdClearColorImage -- -- __Note:__ @vkCmdClearColorImageUnsafe@ and @vkCmdClearColorImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdClearColorImage@ is an alias -- of @vkCmdClearColorImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdClearColorImageSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdClearColorImage" vkCmdClearColorImageSafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ image -> VkImageLayout -- ^ imageLayout -> Ptr VkClearColorValue -- ^ pColor -> Word32 -- ^ rangeCount -> Ptr VkImageSubresourceRange -- ^ pRanges -> IO () #else vkCmdClearColorImageSafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ image -> VkImageLayout -- ^ imageLayout -> Ptr VkClearColorValue -- ^ pColor -> Word32 -- ^ rangeCount -> Ptr VkImageSubresourceRange -- ^ pRanges -> IO () vkCmdClearColorImageSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdClearColorImage) {-# NOINLINE vkCmdClearColorImageSafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdClearColorImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage image -- > , VkImageLayout imageLayout -- > , const VkClearColorValue* pColor -- > , uint32_t rangeCount -- > , const VkImageSubresourceRange* pRanges -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdClearColorImage vkCmdClearColorImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdClearColorImage <- vkGetInstanceProc @VkCmdClearColorImage vkInstance -- -- or less efficient: -- -- > myCmdClearColorImage <- vkGetProc @VkCmdClearColorImage -- -- __Note:__ @vkCmdClearColorImageUnsafe@ and @vkCmdClearColorImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdClearColorImage@ is an alias -- of @vkCmdClearColorImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdClearColorImageSafe@. -- vkCmdClearColorImage :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ image -> VkImageLayout -- ^ imageLayout -> Ptr VkClearColorValue -- ^ pColor -> Word32 -- ^ rangeCount -> Ptr VkImageSubresourceRange -- ^ pRanges -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdClearColorImage = vkCmdClearColorImageUnsafe #else vkCmdClearColorImage = vkCmdClearColorImageSafe #endif {-# INLINE vkCmdClearColorImage #-} -- | Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdClearColorImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage image -- > , VkImageLayout imageLayout -- > , const VkClearColorValue* pColor -- > , uint32_t rangeCount -- > , const VkImageSubresourceRange* pRanges -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdClearColorImage vkCmdClearColorImage registry at www.khronos.org> type HS_vkCmdClearColorImage = VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ image -> VkImageLayout -- ^ imageLayout -> Ptr VkClearColorValue -- ^ pColor -> Word32 -- ^ rangeCount -> Ptr VkImageSubresourceRange -- ^ pRanges -> IO () type PFN_vkCmdClearColorImage = FunPtr HS_vkCmdClearColorImage foreign import ccall unsafe "dynamic" unwrapVkCmdClearColorImageUnsafe :: PFN_vkCmdClearColorImage -> HS_vkCmdClearColorImage foreign import ccall safe "dynamic" unwrapVkCmdClearColorImageSafe :: PFN_vkCmdClearColorImage -> HS_vkCmdClearColorImage instance VulkanProc "vkCmdClearColorImage" where type VkProcType "vkCmdClearColorImage" = HS_vkCmdClearColorImage vkProcSymbol = _VkCmdClearColorImage {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdClearColorImageUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdClearColorImageSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdClearDepthStencilImage :: CString pattern VkCmdClearDepthStencilImage <- (is_VkCmdClearDepthStencilImage -> True) where VkCmdClearDepthStencilImage = _VkCmdClearDepthStencilImage {-# INLINE _VkCmdClearDepthStencilImage #-} _VkCmdClearDepthStencilImage :: CString _VkCmdClearDepthStencilImage = Ptr "vkCmdClearDepthStencilImage\NUL"# {-# INLINE is_VkCmdClearDepthStencilImage #-} is_VkCmdClearDepthStencilImage :: CString -> Bool is_VkCmdClearDepthStencilImage = (EQ ==) . cmpCStrings _VkCmdClearDepthStencilImage type VkCmdClearDepthStencilImage = "vkCmdClearDepthStencilImage" -- | -- Queues: 'graphics'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdClearDepthStencilImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage image -- > , VkImageLayout imageLayout -- > , const VkClearDepthStencilValue* pDepthStencil -- > , uint32_t rangeCount -- > , const VkImageSubresourceRange* pRanges -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdClearDepthStencilImage <- vkGetInstanceProc @VkCmdClearDepthStencilImage vkInstance -- -- or less efficient: -- -- > myCmdClearDepthStencilImage <- vkGetProc @VkCmdClearDepthStencilImage -- -- __Note:__ @vkCmdClearDepthStencilImageUnsafe@ and @vkCmdClearDepthStencilImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdClearDepthStencilImage@ is an alias -- of @vkCmdClearDepthStencilImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdClearDepthStencilImageSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdClearDepthStencilImage" vkCmdClearDepthStencilImageUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ image -> VkImageLayout -- ^ imageLayout -> Ptr VkClearDepthStencilValue -- ^ pDepthStencil -> Word32 -- ^ rangeCount -> Ptr VkImageSubresourceRange -- ^ pRanges -> IO () #else vkCmdClearDepthStencilImageUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ image -> VkImageLayout -- ^ imageLayout -> Ptr VkClearDepthStencilValue -- ^ pDepthStencil -> Word32 -- ^ rangeCount -> Ptr VkImageSubresourceRange -- ^ pRanges -> IO () vkCmdClearDepthStencilImageUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdClearDepthStencilImage) {-# NOINLINE vkCmdClearDepthStencilImageUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdClearDepthStencilImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage image -- > , VkImageLayout imageLayout -- > , const VkClearDepthStencilValue* pDepthStencil -- > , uint32_t rangeCount -- > , const VkImageSubresourceRange* pRanges -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdClearDepthStencilImage <- vkGetInstanceProc @VkCmdClearDepthStencilImage vkInstance -- -- or less efficient: -- -- > myCmdClearDepthStencilImage <- vkGetProc @VkCmdClearDepthStencilImage -- -- __Note:__ @vkCmdClearDepthStencilImageUnsafe@ and @vkCmdClearDepthStencilImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdClearDepthStencilImage@ is an alias -- of @vkCmdClearDepthStencilImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdClearDepthStencilImageSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdClearDepthStencilImage" vkCmdClearDepthStencilImageSafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ image -> VkImageLayout -- ^ imageLayout -> Ptr VkClearDepthStencilValue -- ^ pDepthStencil -> Word32 -- ^ rangeCount -> Ptr VkImageSubresourceRange -- ^ pRanges -> IO () #else vkCmdClearDepthStencilImageSafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ image -> VkImageLayout -- ^ imageLayout -> Ptr VkClearDepthStencilValue -- ^ pDepthStencil -> Word32 -- ^ rangeCount -> Ptr VkImageSubresourceRange -- ^ pRanges -> IO () vkCmdClearDepthStencilImageSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdClearDepthStencilImage) {-# NOINLINE vkCmdClearDepthStencilImageSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdClearDepthStencilImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage image -- > , VkImageLayout imageLayout -- > , const VkClearDepthStencilValue* pDepthStencil -- > , uint32_t rangeCount -- > , const VkImageSubresourceRange* pRanges -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdClearDepthStencilImage <- vkGetInstanceProc @VkCmdClearDepthStencilImage vkInstance -- -- or less efficient: -- -- > myCmdClearDepthStencilImage <- vkGetProc @VkCmdClearDepthStencilImage -- -- __Note:__ @vkCmdClearDepthStencilImageUnsafe@ and @vkCmdClearDepthStencilImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdClearDepthStencilImage@ is an alias -- of @vkCmdClearDepthStencilImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdClearDepthStencilImageSafe@. -- vkCmdClearDepthStencilImage :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ image -> VkImageLayout -- ^ imageLayout -> Ptr VkClearDepthStencilValue -- ^ pDepthStencil -> Word32 -- ^ rangeCount -> Ptr VkImageSubresourceRange -- ^ pRanges -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdClearDepthStencilImage = vkCmdClearDepthStencilImageUnsafe #else vkCmdClearDepthStencilImage = vkCmdClearDepthStencilImageSafe #endif {-# INLINE vkCmdClearDepthStencilImage #-} -- | Queues: 'graphics'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdClearDepthStencilImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage image -- > , VkImageLayout imageLayout -- > , const VkClearDepthStencilValue* pDepthStencil -- > , uint32_t rangeCount -- > , const VkImageSubresourceRange* pRanges -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage registry at www.khronos.org> type HS_vkCmdClearDepthStencilImage = VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ image -> VkImageLayout -- ^ imageLayout -> Ptr VkClearDepthStencilValue -- ^ pDepthStencil -> Word32 -- ^ rangeCount -> Ptr VkImageSubresourceRange -- ^ pRanges -> IO () type PFN_vkCmdClearDepthStencilImage = FunPtr HS_vkCmdClearDepthStencilImage foreign import ccall unsafe "dynamic" unwrapVkCmdClearDepthStencilImageUnsafe :: PFN_vkCmdClearDepthStencilImage -> HS_vkCmdClearDepthStencilImage foreign import ccall safe "dynamic" unwrapVkCmdClearDepthStencilImageSafe :: PFN_vkCmdClearDepthStencilImage -> HS_vkCmdClearDepthStencilImage instance VulkanProc "vkCmdClearDepthStencilImage" where type VkProcType "vkCmdClearDepthStencilImage" = HS_vkCmdClearDepthStencilImage vkProcSymbol = _VkCmdClearDepthStencilImage {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdClearDepthStencilImageUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdClearDepthStencilImageSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdClearAttachments :: CString pattern VkCmdClearAttachments <- (is_VkCmdClearAttachments -> True) where VkCmdClearAttachments = _VkCmdClearAttachments {-# INLINE _VkCmdClearAttachments #-} _VkCmdClearAttachments :: CString _VkCmdClearAttachments = Ptr "vkCmdClearAttachments\NUL"# {-# INLINE is_VkCmdClearAttachments #-} is_VkCmdClearAttachments :: CString -> Bool is_VkCmdClearAttachments = (EQ ==) . cmpCStrings _VkCmdClearAttachments type VkCmdClearAttachments = "vkCmdClearAttachments" -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdClearAttachments -- > ( VkCommandBuffer commandBuffer -- > , uint32_t attachmentCount -- > , const VkClearAttachment* pAttachments -- > , uint32_t rectCount -- > , const VkClearRect* pRects -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdClearAttachments vkCmdClearAttachments registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdClearAttachments <- vkGetInstanceProc @VkCmdClearAttachments vkInstance -- -- or less efficient: -- -- > myCmdClearAttachments <- vkGetProc @VkCmdClearAttachments -- -- __Note:__ @vkCmdClearAttachmentsUnsafe@ and @vkCmdClearAttachmentsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdClearAttachments@ is an alias -- of @vkCmdClearAttachmentsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdClearAttachmentsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdClearAttachments" vkCmdClearAttachmentsUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ attachmentCount -> Ptr VkClearAttachment -- ^ pAttachments -> Word32 -- ^ rectCount -> Ptr VkClearRect -- ^ pRects -> IO () #else vkCmdClearAttachmentsUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ attachmentCount -> Ptr VkClearAttachment -- ^ pAttachments -> Word32 -- ^ rectCount -> Ptr VkClearRect -- ^ pRects -> IO () vkCmdClearAttachmentsUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdClearAttachments) {-# NOINLINE vkCmdClearAttachmentsUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdClearAttachments -- > ( VkCommandBuffer commandBuffer -- > , uint32_t attachmentCount -- > , const VkClearAttachment* pAttachments -- > , uint32_t rectCount -- > , const VkClearRect* pRects -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdClearAttachments vkCmdClearAttachments registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdClearAttachments <- vkGetInstanceProc @VkCmdClearAttachments vkInstance -- -- or less efficient: -- -- > myCmdClearAttachments <- vkGetProc @VkCmdClearAttachments -- -- __Note:__ @vkCmdClearAttachmentsUnsafe@ and @vkCmdClearAttachmentsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdClearAttachments@ is an alias -- of @vkCmdClearAttachmentsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdClearAttachmentsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdClearAttachments" vkCmdClearAttachmentsSafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ attachmentCount -> Ptr VkClearAttachment -- ^ pAttachments -> Word32 -- ^ rectCount -> Ptr VkClearRect -- ^ pRects -> IO () #else vkCmdClearAttachmentsSafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ attachmentCount -> Ptr VkClearAttachment -- ^ pAttachments -> Word32 -- ^ rectCount -> Ptr VkClearRect -- ^ pRects -> IO () vkCmdClearAttachmentsSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdClearAttachments) {-# NOINLINE vkCmdClearAttachmentsSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdClearAttachments -- > ( VkCommandBuffer commandBuffer -- > , uint32_t attachmentCount -- > , const VkClearAttachment* pAttachments -- > , uint32_t rectCount -- > , const VkClearRect* pRects -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdClearAttachments vkCmdClearAttachments registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdClearAttachments <- vkGetInstanceProc @VkCmdClearAttachments vkInstance -- -- or less efficient: -- -- > myCmdClearAttachments <- vkGetProc @VkCmdClearAttachments -- -- __Note:__ @vkCmdClearAttachmentsUnsafe@ and @vkCmdClearAttachmentsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdClearAttachments@ is an alias -- of @vkCmdClearAttachmentsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdClearAttachmentsSafe@. -- vkCmdClearAttachments :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ attachmentCount -> Ptr VkClearAttachment -- ^ pAttachments -> Word32 -- ^ rectCount -> Ptr VkClearRect -- ^ pRects -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdClearAttachments = vkCmdClearAttachmentsUnsafe #else vkCmdClearAttachments = vkCmdClearAttachmentsSafe #endif {-# INLINE vkCmdClearAttachments #-} -- | Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdClearAttachments -- > ( VkCommandBuffer commandBuffer -- > , uint32_t attachmentCount -- > , const VkClearAttachment* pAttachments -- > , uint32_t rectCount -- > , const VkClearRect* pRects -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdClearAttachments vkCmdClearAttachments registry at www.khronos.org> type HS_vkCmdClearAttachments = VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ attachmentCount -> Ptr VkClearAttachment -- ^ pAttachments -> Word32 -- ^ rectCount -> Ptr VkClearRect -- ^ pRects -> IO () type PFN_vkCmdClearAttachments = FunPtr HS_vkCmdClearAttachments foreign import ccall unsafe "dynamic" unwrapVkCmdClearAttachmentsUnsafe :: PFN_vkCmdClearAttachments -> HS_vkCmdClearAttachments foreign import ccall safe "dynamic" unwrapVkCmdClearAttachmentsSafe :: PFN_vkCmdClearAttachments -> HS_vkCmdClearAttachments instance VulkanProc "vkCmdClearAttachments" where type VkProcType "vkCmdClearAttachments" = HS_vkCmdClearAttachments vkProcSymbol = _VkCmdClearAttachments {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdClearAttachmentsUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdClearAttachmentsSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdResolveImage :: CString pattern VkCmdResolveImage <- (is_VkCmdResolveImage -> True) where VkCmdResolveImage = _VkCmdResolveImage {-# INLINE _VkCmdResolveImage #-} _VkCmdResolveImage :: CString _VkCmdResolveImage = Ptr "vkCmdResolveImage\NUL"# {-# INLINE is_VkCmdResolveImage #-} is_VkCmdResolveImage :: CString -> Bool is_VkCmdResolveImage = (EQ ==) . cmpCStrings _VkCmdResolveImage type VkCmdResolveImage = "vkCmdResolveImage" -- | -- Queues: 'graphics'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdResolveImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage srcImage -- > , VkImageLayout srcImageLayout -- > , VkImage dstImage -- > , VkImageLayout dstImageLayout -- > , uint32_t regionCount -- > , const VkImageResolve* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdResolveImage vkCmdResolveImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdResolveImage <- vkGetInstanceProc @VkCmdResolveImage vkInstance -- -- or less efficient: -- -- > myCmdResolveImage <- vkGetProc @VkCmdResolveImage -- -- __Note:__ @vkCmdResolveImageUnsafe@ and @vkCmdResolveImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdResolveImage@ is an alias -- of @vkCmdResolveImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdResolveImageSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdResolveImage" vkCmdResolveImageUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkImageResolve -- ^ pRegions -> IO () #else vkCmdResolveImageUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkImageResolve -- ^ pRegions -> IO () vkCmdResolveImageUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdResolveImage) {-# NOINLINE vkCmdResolveImageUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdResolveImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage srcImage -- > , VkImageLayout srcImageLayout -- > , VkImage dstImage -- > , VkImageLayout dstImageLayout -- > , uint32_t regionCount -- > , const VkImageResolve* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdResolveImage vkCmdResolveImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdResolveImage <- vkGetInstanceProc @VkCmdResolveImage vkInstance -- -- or less efficient: -- -- > myCmdResolveImage <- vkGetProc @VkCmdResolveImage -- -- __Note:__ @vkCmdResolveImageUnsafe@ and @vkCmdResolveImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdResolveImage@ is an alias -- of @vkCmdResolveImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdResolveImageSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdResolveImage" vkCmdResolveImageSafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkImageResolve -- ^ pRegions -> IO () #else vkCmdResolveImageSafe :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkImageResolve -- ^ pRegions -> IO () vkCmdResolveImageSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdResolveImage) {-# NOINLINE vkCmdResolveImageSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdResolveImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage srcImage -- > , VkImageLayout srcImageLayout -- > , VkImage dstImage -- > , VkImageLayout dstImageLayout -- > , uint32_t regionCount -- > , const VkImageResolve* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdResolveImage vkCmdResolveImage registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdResolveImage <- vkGetInstanceProc @VkCmdResolveImage vkInstance -- -- or less efficient: -- -- > myCmdResolveImage <- vkGetProc @VkCmdResolveImage -- -- __Note:__ @vkCmdResolveImageUnsafe@ and @vkCmdResolveImageSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdResolveImage@ is an alias -- of @vkCmdResolveImageUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdResolveImageSafe@. -- vkCmdResolveImage :: VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkImageResolve -- ^ pRegions -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdResolveImage = vkCmdResolveImageUnsafe #else vkCmdResolveImage = vkCmdResolveImageSafe #endif {-# INLINE vkCmdResolveImage #-} -- | Queues: 'graphics'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdResolveImage -- > ( VkCommandBuffer commandBuffer -- > , VkImage srcImage -- > , VkImageLayout srcImageLayout -- > , VkImage dstImage -- > , VkImageLayout dstImageLayout -- > , uint32_t regionCount -- > , const VkImageResolve* pRegions -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdResolveImage vkCmdResolveImage registry at www.khronos.org> type HS_vkCmdResolveImage = VkCommandBuffer -- ^ commandBuffer -> VkImage -- ^ srcImage -> VkImageLayout -- ^ srcImageLayout -> VkImage -- ^ dstImage -> VkImageLayout -- ^ dstImageLayout -> Word32 -- ^ regionCount -> Ptr VkImageResolve -- ^ pRegions -> IO () type PFN_vkCmdResolveImage = FunPtr HS_vkCmdResolveImage foreign import ccall unsafe "dynamic" unwrapVkCmdResolveImageUnsafe :: PFN_vkCmdResolveImage -> HS_vkCmdResolveImage foreign import ccall safe "dynamic" unwrapVkCmdResolveImageSafe :: PFN_vkCmdResolveImage -> HS_vkCmdResolveImage instance VulkanProc "vkCmdResolveImage" where type VkProcType "vkCmdResolveImage" = HS_vkCmdResolveImage vkProcSymbol = _VkCmdResolveImage {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdResolveImageUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdResolveImageSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdSetEvent :: CString pattern VkCmdSetEvent <- (is_VkCmdSetEvent -> True) where VkCmdSetEvent = _VkCmdSetEvent {-# INLINE _VkCmdSetEvent #-} _VkCmdSetEvent :: CString _VkCmdSetEvent = Ptr "vkCmdSetEvent\NUL"# {-# INLINE is_VkCmdSetEvent #-} is_VkCmdSetEvent :: CString -> Bool is_VkCmdSetEvent = (EQ ==) . cmpCStrings _VkCmdSetEvent type VkCmdSetEvent = "vkCmdSetEvent" -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- > void vkCmdSetEvent -- > ( VkCommandBuffer commandBuffer -- > , VkEvent event -- > , VkPipelineStageFlags stageMask -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetEvent vkCmdSetEvent registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetEvent <- vkGetInstanceProc @VkCmdSetEvent vkInstance -- -- or less efficient: -- -- > myCmdSetEvent <- vkGetProc @VkCmdSetEvent -- -- __Note:__ @vkCmdSetEventUnsafe@ and @vkCmdSetEventSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetEvent@ is an alias -- of @vkCmdSetEventUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetEventSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdSetEvent" vkCmdSetEventUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkEvent -- ^ event -> VkPipelineStageFlags -- ^ stageMask -> IO () #else vkCmdSetEventUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkEvent -- ^ event -> VkPipelineStageFlags -- ^ stageMask -> IO () vkCmdSetEventUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdSetEvent) {-# NOINLINE vkCmdSetEventUnsafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- > void vkCmdSetEvent -- > ( VkCommandBuffer commandBuffer -- > , VkEvent event -- > , VkPipelineStageFlags stageMask -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetEvent vkCmdSetEvent registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetEvent <- vkGetInstanceProc @VkCmdSetEvent vkInstance -- -- or less efficient: -- -- > myCmdSetEvent <- vkGetProc @VkCmdSetEvent -- -- __Note:__ @vkCmdSetEventUnsafe@ and @vkCmdSetEventSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetEvent@ is an alias -- of @vkCmdSetEventUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetEventSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdSetEvent" vkCmdSetEventSafe :: VkCommandBuffer -- ^ commandBuffer -> VkEvent -- ^ event -> VkPipelineStageFlags -- ^ stageMask -> IO () #else vkCmdSetEventSafe :: VkCommandBuffer -- ^ commandBuffer -> VkEvent -- ^ event -> VkPipelineStageFlags -- ^ stageMask -> IO () vkCmdSetEventSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdSetEvent) {-# NOINLINE vkCmdSetEventSafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- > void vkCmdSetEvent -- > ( VkCommandBuffer commandBuffer -- > , VkEvent event -- > , VkPipelineStageFlags stageMask -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetEvent vkCmdSetEvent registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdSetEvent <- vkGetInstanceProc @VkCmdSetEvent vkInstance -- -- or less efficient: -- -- > myCmdSetEvent <- vkGetProc @VkCmdSetEvent -- -- __Note:__ @vkCmdSetEventUnsafe@ and @vkCmdSetEventSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdSetEvent@ is an alias -- of @vkCmdSetEventUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdSetEventSafe@. -- vkCmdSetEvent :: VkCommandBuffer -- ^ commandBuffer -> VkEvent -- ^ event -> VkPipelineStageFlags -- ^ stageMask -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdSetEvent = vkCmdSetEventUnsafe #else vkCmdSetEvent = vkCmdSetEventSafe #endif {-# INLINE vkCmdSetEvent #-} -- | Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- > void vkCmdSetEvent -- > ( VkCommandBuffer commandBuffer -- > , VkEvent event -- > , VkPipelineStageFlags stageMask -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdSetEvent vkCmdSetEvent registry at www.khronos.org> type HS_vkCmdSetEvent = VkCommandBuffer -- ^ commandBuffer -> VkEvent -- ^ event -> VkPipelineStageFlags -- ^ stageMask -> IO () type PFN_vkCmdSetEvent = FunPtr HS_vkCmdSetEvent foreign import ccall unsafe "dynamic" unwrapVkCmdSetEventUnsafe :: PFN_vkCmdSetEvent -> HS_vkCmdSetEvent foreign import ccall safe "dynamic" unwrapVkCmdSetEventSafe :: PFN_vkCmdSetEvent -> HS_vkCmdSetEvent instance VulkanProc "vkCmdSetEvent" where type VkProcType "vkCmdSetEvent" = HS_vkCmdSetEvent vkProcSymbol = _VkCmdSetEvent {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdSetEventUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdSetEventSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdResetEvent :: CString pattern VkCmdResetEvent <- (is_VkCmdResetEvent -> True) where VkCmdResetEvent = _VkCmdResetEvent {-# INLINE _VkCmdResetEvent #-} _VkCmdResetEvent :: CString _VkCmdResetEvent = Ptr "vkCmdResetEvent\NUL"# {-# INLINE is_VkCmdResetEvent #-} is_VkCmdResetEvent :: CString -> Bool is_VkCmdResetEvent = (EQ ==) . cmpCStrings _VkCmdResetEvent type VkCmdResetEvent = "vkCmdResetEvent" -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- > void vkCmdResetEvent -- > ( VkCommandBuffer commandBuffer -- > , VkEvent event -- > , VkPipelineStageFlags stageMask -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdResetEvent vkCmdResetEvent registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdResetEvent <- vkGetInstanceProc @VkCmdResetEvent vkInstance -- -- or less efficient: -- -- > myCmdResetEvent <- vkGetProc @VkCmdResetEvent -- -- __Note:__ @vkCmdResetEventUnsafe@ and @vkCmdResetEventSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdResetEvent@ is an alias -- of @vkCmdResetEventUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdResetEventSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdResetEvent" vkCmdResetEventUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkEvent -- ^ event -> VkPipelineStageFlags -- ^ stageMask -> IO () #else vkCmdResetEventUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkEvent -- ^ event -> VkPipelineStageFlags -- ^ stageMask -> IO () vkCmdResetEventUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdResetEvent) {-# NOINLINE vkCmdResetEventUnsafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- > void vkCmdResetEvent -- > ( VkCommandBuffer commandBuffer -- > , VkEvent event -- > , VkPipelineStageFlags stageMask -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdResetEvent vkCmdResetEvent registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdResetEvent <- vkGetInstanceProc @VkCmdResetEvent vkInstance -- -- or less efficient: -- -- > myCmdResetEvent <- vkGetProc @VkCmdResetEvent -- -- __Note:__ @vkCmdResetEventUnsafe@ and @vkCmdResetEventSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdResetEvent@ is an alias -- of @vkCmdResetEventUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdResetEventSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdResetEvent" vkCmdResetEventSafe :: VkCommandBuffer -- ^ commandBuffer -> VkEvent -- ^ event -> VkPipelineStageFlags -- ^ stageMask -> IO () #else vkCmdResetEventSafe :: VkCommandBuffer -- ^ commandBuffer -> VkEvent -- ^ event -> VkPipelineStageFlags -- ^ stageMask -> IO () vkCmdResetEventSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdResetEvent) {-# NOINLINE vkCmdResetEventSafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- > void vkCmdResetEvent -- > ( VkCommandBuffer commandBuffer -- > , VkEvent event -- > , VkPipelineStageFlags stageMask -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdResetEvent vkCmdResetEvent registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdResetEvent <- vkGetInstanceProc @VkCmdResetEvent vkInstance -- -- or less efficient: -- -- > myCmdResetEvent <- vkGetProc @VkCmdResetEvent -- -- __Note:__ @vkCmdResetEventUnsafe@ and @vkCmdResetEventSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdResetEvent@ is an alias -- of @vkCmdResetEventUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdResetEventSafe@. -- vkCmdResetEvent :: VkCommandBuffer -- ^ commandBuffer -> VkEvent -- ^ event -> VkPipelineStageFlags -- ^ stageMask -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdResetEvent = vkCmdResetEventUnsafe #else vkCmdResetEvent = vkCmdResetEventSafe #endif {-# INLINE vkCmdResetEvent #-} -- | Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- > void vkCmdResetEvent -- > ( VkCommandBuffer commandBuffer -- > , VkEvent event -- > , VkPipelineStageFlags stageMask -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdResetEvent vkCmdResetEvent registry at www.khronos.org> type HS_vkCmdResetEvent = VkCommandBuffer -- ^ commandBuffer -> VkEvent -- ^ event -> VkPipelineStageFlags -- ^ stageMask -> IO () type PFN_vkCmdResetEvent = FunPtr HS_vkCmdResetEvent foreign import ccall unsafe "dynamic" unwrapVkCmdResetEventUnsafe :: PFN_vkCmdResetEvent -> HS_vkCmdResetEvent foreign import ccall safe "dynamic" unwrapVkCmdResetEventSafe :: PFN_vkCmdResetEvent -> HS_vkCmdResetEvent instance VulkanProc "vkCmdResetEvent" where type VkProcType "vkCmdResetEvent" = HS_vkCmdResetEvent vkProcSymbol = _VkCmdResetEvent {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdResetEventUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdResetEventSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdWaitEvents :: CString pattern VkCmdWaitEvents <- (is_VkCmdWaitEvents -> True) where VkCmdWaitEvents = _VkCmdWaitEvents {-# INLINE _VkCmdWaitEvents #-} _VkCmdWaitEvents :: CString _VkCmdWaitEvents = Ptr "vkCmdWaitEvents\NUL"# {-# INLINE is_VkCmdWaitEvents #-} is_VkCmdWaitEvents :: CString -> Bool is_VkCmdWaitEvents = (EQ ==) . cmpCStrings _VkCmdWaitEvents type VkCmdWaitEvents = "vkCmdWaitEvents" -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdWaitEvents -- > ( VkCommandBuffer commandBuffer -- > , uint32_t eventCount -- > , const VkEvent* pEvents -- > , VkPipelineStageFlags srcStageMask -- > , VkPipelineStageFlags dstStageMask -- > , uint32_t memoryBarrierCount -- > , const VkMemoryBarrier* pMemoryBarriers -- > , uint32_t bufferMemoryBarrierCount -- > , const VkBufferMemoryBarrier* pBufferMemoryBarriers -- > , uint32_t imageMemoryBarrierCount -- > , const VkImageMemoryBarrier* pImageMemoryBarriers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdWaitEvents vkCmdWaitEvents registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdWaitEvents <- vkGetInstanceProc @VkCmdWaitEvents vkInstance -- -- or less efficient: -- -- > myCmdWaitEvents <- vkGetProc @VkCmdWaitEvents -- -- __Note:__ @vkCmdWaitEventsUnsafe@ and @vkCmdWaitEventsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdWaitEvents@ is an alias -- of @vkCmdWaitEventsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdWaitEventsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdWaitEvents" vkCmdWaitEventsUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ eventCount -> Ptr VkEvent -- ^ pEvents -> VkPipelineStageFlags -- ^ srcStageMask -> VkPipelineStageFlags -- ^ dstStageMask -> Word32 -- ^ memoryBarrierCount -> Ptr VkMemoryBarrier -- ^ pMemoryBarriers -> Word32 -- ^ bufferMemoryBarrierCount -> Ptr VkBufferMemoryBarrier -- ^ pBufferMemoryBarriers -> Word32 -- ^ imageMemoryBarrierCount -> Ptr VkImageMemoryBarrier -- ^ pImageMemoryBarriers -> IO () #else vkCmdWaitEventsUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ eventCount -> Ptr VkEvent -- ^ pEvents -> VkPipelineStageFlags -- ^ srcStageMask -> VkPipelineStageFlags -- ^ dstStageMask -> Word32 -- ^ memoryBarrierCount -> Ptr VkMemoryBarrier -- ^ pMemoryBarriers -> Word32 -- ^ bufferMemoryBarrierCount -> Ptr VkBufferMemoryBarrier -- ^ pBufferMemoryBarriers -> Word32 -- ^ imageMemoryBarrierCount -> Ptr VkImageMemoryBarrier -- ^ pImageMemoryBarriers -> IO () vkCmdWaitEventsUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdWaitEvents) {-# NOINLINE vkCmdWaitEventsUnsafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdWaitEvents -- > ( VkCommandBuffer commandBuffer -- > , uint32_t eventCount -- > , const VkEvent* pEvents -- > , VkPipelineStageFlags srcStageMask -- > , VkPipelineStageFlags dstStageMask -- > , uint32_t memoryBarrierCount -- > , const VkMemoryBarrier* pMemoryBarriers -- > , uint32_t bufferMemoryBarrierCount -- > , const VkBufferMemoryBarrier* pBufferMemoryBarriers -- > , uint32_t imageMemoryBarrierCount -- > , const VkImageMemoryBarrier* pImageMemoryBarriers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdWaitEvents vkCmdWaitEvents registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdWaitEvents <- vkGetInstanceProc @VkCmdWaitEvents vkInstance -- -- or less efficient: -- -- > myCmdWaitEvents <- vkGetProc @VkCmdWaitEvents -- -- __Note:__ @vkCmdWaitEventsUnsafe@ and @vkCmdWaitEventsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdWaitEvents@ is an alias -- of @vkCmdWaitEventsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdWaitEventsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdWaitEvents" vkCmdWaitEventsSafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ eventCount -> Ptr VkEvent -- ^ pEvents -> VkPipelineStageFlags -- ^ srcStageMask -> VkPipelineStageFlags -- ^ dstStageMask -> Word32 -- ^ memoryBarrierCount -> Ptr VkMemoryBarrier -- ^ pMemoryBarriers -> Word32 -- ^ bufferMemoryBarrierCount -> Ptr VkBufferMemoryBarrier -- ^ pBufferMemoryBarriers -> Word32 -- ^ imageMemoryBarrierCount -> Ptr VkImageMemoryBarrier -- ^ pImageMemoryBarriers -> IO () #else vkCmdWaitEventsSafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ eventCount -> Ptr VkEvent -- ^ pEvents -> VkPipelineStageFlags -- ^ srcStageMask -> VkPipelineStageFlags -- ^ dstStageMask -> Word32 -- ^ memoryBarrierCount -> Ptr VkMemoryBarrier -- ^ pMemoryBarriers -> Word32 -- ^ bufferMemoryBarrierCount -> Ptr VkBufferMemoryBarrier -- ^ pBufferMemoryBarriers -> Word32 -- ^ imageMemoryBarrierCount -> Ptr VkImageMemoryBarrier -- ^ pImageMemoryBarriers -> IO () vkCmdWaitEventsSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdWaitEvents) {-# NOINLINE vkCmdWaitEventsSafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdWaitEvents -- > ( VkCommandBuffer commandBuffer -- > , uint32_t eventCount -- > , const VkEvent* pEvents -- > , VkPipelineStageFlags srcStageMask -- > , VkPipelineStageFlags dstStageMask -- > , uint32_t memoryBarrierCount -- > , const VkMemoryBarrier* pMemoryBarriers -- > , uint32_t bufferMemoryBarrierCount -- > , const VkBufferMemoryBarrier* pBufferMemoryBarriers -- > , uint32_t imageMemoryBarrierCount -- > , const VkImageMemoryBarrier* pImageMemoryBarriers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdWaitEvents vkCmdWaitEvents registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdWaitEvents <- vkGetInstanceProc @VkCmdWaitEvents vkInstance -- -- or less efficient: -- -- > myCmdWaitEvents <- vkGetProc @VkCmdWaitEvents -- -- __Note:__ @vkCmdWaitEventsUnsafe@ and @vkCmdWaitEventsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdWaitEvents@ is an alias -- of @vkCmdWaitEventsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdWaitEventsSafe@. -- vkCmdWaitEvents :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ eventCount -> Ptr VkEvent -- ^ pEvents -> VkPipelineStageFlags -- ^ srcStageMask -> VkPipelineStageFlags -- ^ dstStageMask -> Word32 -- ^ memoryBarrierCount -> Ptr VkMemoryBarrier -- ^ pMemoryBarriers -> Word32 -- ^ bufferMemoryBarrierCount -> Ptr VkBufferMemoryBarrier -- ^ pBufferMemoryBarriers -> Word32 -- ^ imageMemoryBarrierCount -> Ptr VkImageMemoryBarrier -- ^ pImageMemoryBarriers -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdWaitEvents = vkCmdWaitEventsUnsafe #else vkCmdWaitEvents = vkCmdWaitEventsSafe #endif {-# INLINE vkCmdWaitEvents #-} -- | Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdWaitEvents -- > ( VkCommandBuffer commandBuffer -- > , uint32_t eventCount -- > , const VkEvent* pEvents -- > , VkPipelineStageFlags srcStageMask -- > , VkPipelineStageFlags dstStageMask -- > , uint32_t memoryBarrierCount -- > , const VkMemoryBarrier* pMemoryBarriers -- > , uint32_t bufferMemoryBarrierCount -- > , const VkBufferMemoryBarrier* pBufferMemoryBarriers -- > , uint32_t imageMemoryBarrierCount -- > , const VkImageMemoryBarrier* pImageMemoryBarriers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdWaitEvents vkCmdWaitEvents registry at www.khronos.org> type HS_vkCmdWaitEvents = VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ eventCount -> Ptr VkEvent -- ^ pEvents -> VkPipelineStageFlags -- ^ srcStageMask -> VkPipelineStageFlags -- ^ dstStageMask -> Word32 -- ^ memoryBarrierCount -> Ptr VkMemoryBarrier -- ^ pMemoryBarriers -> Word32 -- ^ bufferMemoryBarrierCount -> Ptr VkBufferMemoryBarrier -- ^ pBufferMemoryBarriers -> Word32 -- ^ imageMemoryBarrierCount -> Ptr VkImageMemoryBarrier -- ^ pImageMemoryBarriers -> IO () type PFN_vkCmdWaitEvents = FunPtr HS_vkCmdWaitEvents foreign import ccall unsafe "dynamic" unwrapVkCmdWaitEventsUnsafe :: PFN_vkCmdWaitEvents -> HS_vkCmdWaitEvents foreign import ccall safe "dynamic" unwrapVkCmdWaitEventsSafe :: PFN_vkCmdWaitEvents -> HS_vkCmdWaitEvents instance VulkanProc "vkCmdWaitEvents" where type VkProcType "vkCmdWaitEvents" = HS_vkCmdWaitEvents vkProcSymbol = _VkCmdWaitEvents {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdWaitEventsUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdWaitEventsSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdPipelineBarrier :: CString pattern VkCmdPipelineBarrier <- (is_VkCmdPipelineBarrier -> True) where VkCmdPipelineBarrier = _VkCmdPipelineBarrier {-# INLINE _VkCmdPipelineBarrier #-} _VkCmdPipelineBarrier :: CString _VkCmdPipelineBarrier = Ptr "vkCmdPipelineBarrier\NUL"# {-# INLINE is_VkCmdPipelineBarrier #-} is_VkCmdPipelineBarrier :: CString -> Bool is_VkCmdPipelineBarrier = (EQ ==) . cmpCStrings _VkCmdPipelineBarrier type VkCmdPipelineBarrier = "vkCmdPipelineBarrier" -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdPipelineBarrier -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineStageFlags srcStageMask -- > , VkPipelineStageFlags dstStageMask -- > , VkDependencyFlags dependencyFlags -- > , uint32_t memoryBarrierCount -- > , const VkMemoryBarrier* pMemoryBarriers -- > , uint32_t bufferMemoryBarrierCount -- > , const VkBufferMemoryBarrier* pBufferMemoryBarriers -- > , uint32_t imageMemoryBarrierCount -- > , const VkImageMemoryBarrier* pImageMemoryBarriers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdPipelineBarrier vkCmdPipelineBarrier registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdPipelineBarrier <- vkGetInstanceProc @VkCmdPipelineBarrier vkInstance -- -- or less efficient: -- -- > myCmdPipelineBarrier <- vkGetProc @VkCmdPipelineBarrier -- -- __Note:__ @vkCmdPipelineBarrierUnsafe@ and @vkCmdPipelineBarrierSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdPipelineBarrier@ is an alias -- of @vkCmdPipelineBarrierUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdPipelineBarrierSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdPipelineBarrier" vkCmdPipelineBarrierUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineStageFlags -- ^ srcStageMask -> VkPipelineStageFlags -- ^ dstStageMask -> VkDependencyFlags -- ^ dependencyFlags -> Word32 -- ^ memoryBarrierCount -> Ptr VkMemoryBarrier -- ^ pMemoryBarriers -> Word32 -- ^ bufferMemoryBarrierCount -> Ptr VkBufferMemoryBarrier -- ^ pBufferMemoryBarriers -> Word32 -- ^ imageMemoryBarrierCount -> Ptr VkImageMemoryBarrier -- ^ pImageMemoryBarriers -> IO () #else vkCmdPipelineBarrierUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineStageFlags -- ^ srcStageMask -> VkPipelineStageFlags -- ^ dstStageMask -> VkDependencyFlags -- ^ dependencyFlags -> Word32 -- ^ memoryBarrierCount -> Ptr VkMemoryBarrier -- ^ pMemoryBarriers -> Word32 -- ^ bufferMemoryBarrierCount -> Ptr VkBufferMemoryBarrier -- ^ pBufferMemoryBarriers -> Word32 -- ^ imageMemoryBarrierCount -> Ptr VkImageMemoryBarrier -- ^ pImageMemoryBarriers -> IO () vkCmdPipelineBarrierUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdPipelineBarrier) {-# NOINLINE vkCmdPipelineBarrierUnsafe #-} #endif -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdPipelineBarrier -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineStageFlags srcStageMask -- > , VkPipelineStageFlags dstStageMask -- > , VkDependencyFlags dependencyFlags -- > , uint32_t memoryBarrierCount -- > , const VkMemoryBarrier* pMemoryBarriers -- > , uint32_t bufferMemoryBarrierCount -- > , const VkBufferMemoryBarrier* pBufferMemoryBarriers -- > , uint32_t imageMemoryBarrierCount -- > , const VkImageMemoryBarrier* pImageMemoryBarriers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdPipelineBarrier vkCmdPipelineBarrier registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdPipelineBarrier <- vkGetInstanceProc @VkCmdPipelineBarrier vkInstance -- -- or less efficient: -- -- > myCmdPipelineBarrier <- vkGetProc @VkCmdPipelineBarrier -- -- __Note:__ @vkCmdPipelineBarrierUnsafe@ and @vkCmdPipelineBarrierSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdPipelineBarrier@ is an alias -- of @vkCmdPipelineBarrierUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdPipelineBarrierSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdPipelineBarrier" vkCmdPipelineBarrierSafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineStageFlags -- ^ srcStageMask -> VkPipelineStageFlags -- ^ dstStageMask -> VkDependencyFlags -- ^ dependencyFlags -> Word32 -- ^ memoryBarrierCount -> Ptr VkMemoryBarrier -- ^ pMemoryBarriers -> Word32 -- ^ bufferMemoryBarrierCount -> Ptr VkBufferMemoryBarrier -- ^ pBufferMemoryBarriers -> Word32 -- ^ imageMemoryBarrierCount -> Ptr VkImageMemoryBarrier -- ^ pImageMemoryBarriers -> IO () #else vkCmdPipelineBarrierSafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineStageFlags -- ^ srcStageMask -> VkPipelineStageFlags -- ^ dstStageMask -> VkDependencyFlags -- ^ dependencyFlags -> Word32 -- ^ memoryBarrierCount -> Ptr VkMemoryBarrier -- ^ pMemoryBarriers -> Word32 -- ^ bufferMemoryBarrierCount -> Ptr VkBufferMemoryBarrier -- ^ pBufferMemoryBarriers -> Word32 -- ^ imageMemoryBarrierCount -> Ptr VkImageMemoryBarrier -- ^ pImageMemoryBarriers -> IO () vkCmdPipelineBarrierSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdPipelineBarrier) {-# NOINLINE vkCmdPipelineBarrierSafe #-} #endif -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdPipelineBarrier -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineStageFlags srcStageMask -- > , VkPipelineStageFlags dstStageMask -- > , VkDependencyFlags dependencyFlags -- > , uint32_t memoryBarrierCount -- > , const VkMemoryBarrier* pMemoryBarriers -- > , uint32_t bufferMemoryBarrierCount -- > , const VkBufferMemoryBarrier* pBufferMemoryBarriers -- > , uint32_t imageMemoryBarrierCount -- > , const VkImageMemoryBarrier* pImageMemoryBarriers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdPipelineBarrier vkCmdPipelineBarrier registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdPipelineBarrier <- vkGetInstanceProc @VkCmdPipelineBarrier vkInstance -- -- or less efficient: -- -- > myCmdPipelineBarrier <- vkGetProc @VkCmdPipelineBarrier -- -- __Note:__ @vkCmdPipelineBarrierUnsafe@ and @vkCmdPipelineBarrierSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdPipelineBarrier@ is an alias -- of @vkCmdPipelineBarrierUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdPipelineBarrierSafe@. -- vkCmdPipelineBarrier :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineStageFlags -- ^ srcStageMask -> VkPipelineStageFlags -- ^ dstStageMask -> VkDependencyFlags -- ^ dependencyFlags -> Word32 -- ^ memoryBarrierCount -> Ptr VkMemoryBarrier -- ^ pMemoryBarriers -> Word32 -- ^ bufferMemoryBarrierCount -> Ptr VkBufferMemoryBarrier -- ^ pBufferMemoryBarriers -> Word32 -- ^ imageMemoryBarrierCount -> Ptr VkImageMemoryBarrier -- ^ pImageMemoryBarriers -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdPipelineBarrier = vkCmdPipelineBarrierUnsafe #else vkCmdPipelineBarrier = vkCmdPipelineBarrierSafe #endif {-# INLINE vkCmdPipelineBarrier #-} -- | Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdPipelineBarrier -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineStageFlags srcStageMask -- > , VkPipelineStageFlags dstStageMask -- > , VkDependencyFlags dependencyFlags -- > , uint32_t memoryBarrierCount -- > , const VkMemoryBarrier* pMemoryBarriers -- > , uint32_t bufferMemoryBarrierCount -- > , const VkBufferMemoryBarrier* pBufferMemoryBarriers -- > , uint32_t imageMemoryBarrierCount -- > , const VkImageMemoryBarrier* pImageMemoryBarriers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdPipelineBarrier vkCmdPipelineBarrier registry at www.khronos.org> type HS_vkCmdPipelineBarrier = VkCommandBuffer -- ^ commandBuffer -> VkPipelineStageFlags -- ^ srcStageMask -> VkPipelineStageFlags -- ^ dstStageMask -> VkDependencyFlags -- ^ dependencyFlags -> Word32 -- ^ memoryBarrierCount -> Ptr VkMemoryBarrier -- ^ pMemoryBarriers -> Word32 -- ^ bufferMemoryBarrierCount -> Ptr VkBufferMemoryBarrier -- ^ pBufferMemoryBarriers -> Word32 -- ^ imageMemoryBarrierCount -> Ptr VkImageMemoryBarrier -- ^ pImageMemoryBarriers -> IO () type PFN_vkCmdPipelineBarrier = FunPtr HS_vkCmdPipelineBarrier foreign import ccall unsafe "dynamic" unwrapVkCmdPipelineBarrierUnsafe :: PFN_vkCmdPipelineBarrier -> HS_vkCmdPipelineBarrier foreign import ccall safe "dynamic" unwrapVkCmdPipelineBarrierSafe :: PFN_vkCmdPipelineBarrier -> HS_vkCmdPipelineBarrier instance VulkanProc "vkCmdPipelineBarrier" where type VkProcType "vkCmdPipelineBarrier" = HS_vkCmdPipelineBarrier vkProcSymbol = _VkCmdPipelineBarrier {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdPipelineBarrierUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdPipelineBarrierSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdBeginQuery :: CString pattern VkCmdBeginQuery <- (is_VkCmdBeginQuery -> True) where VkCmdBeginQuery = _VkCmdBeginQuery {-# INLINE _VkCmdBeginQuery #-} _VkCmdBeginQuery :: CString _VkCmdBeginQuery = Ptr "vkCmdBeginQuery\NUL"# {-# INLINE is_VkCmdBeginQuery #-} is_VkCmdBeginQuery :: CString -> Bool is_VkCmdBeginQuery = (EQ ==) . cmpCStrings _VkCmdBeginQuery type VkCmdBeginQuery = "vkCmdBeginQuery" -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdBeginQuery -- > ( VkCommandBuffer commandBuffer -- > , VkQueryPool queryPool -- > , uint32_t query -- > , VkQueryControlFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBeginQuery vkCmdBeginQuery registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBeginQuery <- vkGetInstanceProc @VkCmdBeginQuery vkInstance -- -- or less efficient: -- -- > myCmdBeginQuery <- vkGetProc @VkCmdBeginQuery -- -- __Note:__ @vkCmdBeginQueryUnsafe@ and @vkCmdBeginQuerySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBeginQuery@ is an alias -- of @vkCmdBeginQueryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBeginQuerySafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdBeginQuery" vkCmdBeginQueryUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ query -> VkQueryControlFlags -- ^ flags -> IO () #else vkCmdBeginQueryUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ query -> VkQueryControlFlags -- ^ flags -> IO () vkCmdBeginQueryUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdBeginQuery) {-# NOINLINE vkCmdBeginQueryUnsafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdBeginQuery -- > ( VkCommandBuffer commandBuffer -- > , VkQueryPool queryPool -- > , uint32_t query -- > , VkQueryControlFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBeginQuery vkCmdBeginQuery registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBeginQuery <- vkGetInstanceProc @VkCmdBeginQuery vkInstance -- -- or less efficient: -- -- > myCmdBeginQuery <- vkGetProc @VkCmdBeginQuery -- -- __Note:__ @vkCmdBeginQueryUnsafe@ and @vkCmdBeginQuerySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBeginQuery@ is an alias -- of @vkCmdBeginQueryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBeginQuerySafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdBeginQuery" vkCmdBeginQuerySafe :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ query -> VkQueryControlFlags -- ^ flags -> IO () #else vkCmdBeginQuerySafe :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ query -> VkQueryControlFlags -- ^ flags -> IO () vkCmdBeginQuerySafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdBeginQuery) {-# NOINLINE vkCmdBeginQuerySafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdBeginQuery -- > ( VkCommandBuffer commandBuffer -- > , VkQueryPool queryPool -- > , uint32_t query -- > , VkQueryControlFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBeginQuery vkCmdBeginQuery registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBeginQuery <- vkGetInstanceProc @VkCmdBeginQuery vkInstance -- -- or less efficient: -- -- > myCmdBeginQuery <- vkGetProc @VkCmdBeginQuery -- -- __Note:__ @vkCmdBeginQueryUnsafe@ and @vkCmdBeginQuerySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBeginQuery@ is an alias -- of @vkCmdBeginQueryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBeginQuerySafe@. -- vkCmdBeginQuery :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ query -> VkQueryControlFlags -- ^ flags -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdBeginQuery = vkCmdBeginQueryUnsafe #else vkCmdBeginQuery = vkCmdBeginQuerySafe #endif {-# INLINE vkCmdBeginQuery #-} -- | Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdBeginQuery -- > ( VkCommandBuffer commandBuffer -- > , VkQueryPool queryPool -- > , uint32_t query -- > , VkQueryControlFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBeginQuery vkCmdBeginQuery registry at www.khronos.org> type HS_vkCmdBeginQuery = VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ query -> VkQueryControlFlags -- ^ flags -> IO () type PFN_vkCmdBeginQuery = FunPtr HS_vkCmdBeginQuery foreign import ccall unsafe "dynamic" unwrapVkCmdBeginQueryUnsafe :: PFN_vkCmdBeginQuery -> HS_vkCmdBeginQuery foreign import ccall safe "dynamic" unwrapVkCmdBeginQuerySafe :: PFN_vkCmdBeginQuery -> HS_vkCmdBeginQuery instance VulkanProc "vkCmdBeginQuery" where type VkProcType "vkCmdBeginQuery" = HS_vkCmdBeginQuery vkProcSymbol = _VkCmdBeginQuery {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdBeginQueryUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdBeginQuerySafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdEndQuery :: CString pattern VkCmdEndQuery <- (is_VkCmdEndQuery -> True) where VkCmdEndQuery = _VkCmdEndQuery {-# INLINE _VkCmdEndQuery #-} _VkCmdEndQuery :: CString _VkCmdEndQuery = Ptr "vkCmdEndQuery\NUL"# {-# INLINE is_VkCmdEndQuery #-} is_VkCmdEndQuery :: CString -> Bool is_VkCmdEndQuery = (EQ ==) . cmpCStrings _VkCmdEndQuery type VkCmdEndQuery = "vkCmdEndQuery" -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdEndQuery -- > ( VkCommandBuffer commandBuffer -- > , VkQueryPool queryPool -- > , uint32_t query -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdEndQuery vkCmdEndQuery registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdEndQuery <- vkGetInstanceProc @VkCmdEndQuery vkInstance -- -- or less efficient: -- -- > myCmdEndQuery <- vkGetProc @VkCmdEndQuery -- -- __Note:__ @vkCmdEndQueryUnsafe@ and @vkCmdEndQuerySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdEndQuery@ is an alias -- of @vkCmdEndQueryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdEndQuerySafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdEndQuery" vkCmdEndQueryUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ query -> IO () #else vkCmdEndQueryUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ query -> IO () vkCmdEndQueryUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdEndQuery) {-# NOINLINE vkCmdEndQueryUnsafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdEndQuery -- > ( VkCommandBuffer commandBuffer -- > , VkQueryPool queryPool -- > , uint32_t query -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdEndQuery vkCmdEndQuery registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdEndQuery <- vkGetInstanceProc @VkCmdEndQuery vkInstance -- -- or less efficient: -- -- > myCmdEndQuery <- vkGetProc @VkCmdEndQuery -- -- __Note:__ @vkCmdEndQueryUnsafe@ and @vkCmdEndQuerySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdEndQuery@ is an alias -- of @vkCmdEndQueryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdEndQuerySafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdEndQuery" vkCmdEndQuerySafe :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ query -> IO () #else vkCmdEndQuerySafe :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ query -> IO () vkCmdEndQuerySafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdEndQuery) {-# NOINLINE vkCmdEndQuerySafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdEndQuery -- > ( VkCommandBuffer commandBuffer -- > , VkQueryPool queryPool -- > , uint32_t query -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdEndQuery vkCmdEndQuery registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdEndQuery <- vkGetInstanceProc @VkCmdEndQuery vkInstance -- -- or less efficient: -- -- > myCmdEndQuery <- vkGetProc @VkCmdEndQuery -- -- __Note:__ @vkCmdEndQueryUnsafe@ and @vkCmdEndQuerySafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdEndQuery@ is an alias -- of @vkCmdEndQueryUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdEndQuerySafe@. -- vkCmdEndQuery :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ query -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdEndQuery = vkCmdEndQueryUnsafe #else vkCmdEndQuery = vkCmdEndQuerySafe #endif {-# INLINE vkCmdEndQuery #-} -- | Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdEndQuery -- > ( VkCommandBuffer commandBuffer -- > , VkQueryPool queryPool -- > , uint32_t query -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdEndQuery vkCmdEndQuery registry at www.khronos.org> type HS_vkCmdEndQuery = VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ query -> IO () type PFN_vkCmdEndQuery = FunPtr HS_vkCmdEndQuery foreign import ccall unsafe "dynamic" unwrapVkCmdEndQueryUnsafe :: PFN_vkCmdEndQuery -> HS_vkCmdEndQuery foreign import ccall safe "dynamic" unwrapVkCmdEndQuerySafe :: PFN_vkCmdEndQuery -> HS_vkCmdEndQuery instance VulkanProc "vkCmdEndQuery" where type VkProcType "vkCmdEndQuery" = HS_vkCmdEndQuery vkProcSymbol = _VkCmdEndQuery {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdEndQueryUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdEndQuerySafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdResetQueryPool :: CString pattern VkCmdResetQueryPool <- (is_VkCmdResetQueryPool -> True) where VkCmdResetQueryPool = _VkCmdResetQueryPool {-# INLINE _VkCmdResetQueryPool #-} _VkCmdResetQueryPool :: CString _VkCmdResetQueryPool = Ptr "vkCmdResetQueryPool\NUL"# {-# INLINE is_VkCmdResetQueryPool #-} is_VkCmdResetQueryPool :: CString -> Bool is_VkCmdResetQueryPool = (EQ ==) . cmpCStrings _VkCmdResetQueryPool type VkCmdResetQueryPool = "vkCmdResetQueryPool" -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- > void vkCmdResetQueryPool -- > ( VkCommandBuffer commandBuffer -- > , VkQueryPool queryPool -- > , uint32_t firstQuery -- > , uint32_t queryCount -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdResetQueryPool vkCmdResetQueryPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdResetQueryPool <- vkGetInstanceProc @VkCmdResetQueryPool vkInstance -- -- or less efficient: -- -- > myCmdResetQueryPool <- vkGetProc @VkCmdResetQueryPool -- -- __Note:__ @vkCmdResetQueryPoolUnsafe@ and @vkCmdResetQueryPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdResetQueryPool@ is an alias -- of @vkCmdResetQueryPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdResetQueryPoolSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdResetQueryPool" vkCmdResetQueryPoolUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ firstQuery -> Word32 -- ^ queryCount -> IO () #else vkCmdResetQueryPoolUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ firstQuery -> Word32 -- ^ queryCount -> IO () vkCmdResetQueryPoolUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdResetQueryPool) {-# NOINLINE vkCmdResetQueryPoolUnsafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- > void vkCmdResetQueryPool -- > ( VkCommandBuffer commandBuffer -- > , VkQueryPool queryPool -- > , uint32_t firstQuery -- > , uint32_t queryCount -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdResetQueryPool vkCmdResetQueryPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdResetQueryPool <- vkGetInstanceProc @VkCmdResetQueryPool vkInstance -- -- or less efficient: -- -- > myCmdResetQueryPool <- vkGetProc @VkCmdResetQueryPool -- -- __Note:__ @vkCmdResetQueryPoolUnsafe@ and @vkCmdResetQueryPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdResetQueryPool@ is an alias -- of @vkCmdResetQueryPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdResetQueryPoolSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdResetQueryPool" vkCmdResetQueryPoolSafe :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ firstQuery -> Word32 -- ^ queryCount -> IO () #else vkCmdResetQueryPoolSafe :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ firstQuery -> Word32 -- ^ queryCount -> IO () vkCmdResetQueryPoolSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdResetQueryPool) {-# NOINLINE vkCmdResetQueryPoolSafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- > void vkCmdResetQueryPool -- > ( VkCommandBuffer commandBuffer -- > , VkQueryPool queryPool -- > , uint32_t firstQuery -- > , uint32_t queryCount -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdResetQueryPool vkCmdResetQueryPool registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdResetQueryPool <- vkGetInstanceProc @VkCmdResetQueryPool vkInstance -- -- or less efficient: -- -- > myCmdResetQueryPool <- vkGetProc @VkCmdResetQueryPool -- -- __Note:__ @vkCmdResetQueryPoolUnsafe@ and @vkCmdResetQueryPoolSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdResetQueryPool@ is an alias -- of @vkCmdResetQueryPoolUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdResetQueryPoolSafe@. -- vkCmdResetQueryPool :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ firstQuery -> Word32 -- ^ queryCount -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdResetQueryPool = vkCmdResetQueryPoolUnsafe #else vkCmdResetQueryPool = vkCmdResetQueryPoolSafe #endif {-# INLINE vkCmdResetQueryPool #-} -- | Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- > void vkCmdResetQueryPool -- > ( VkCommandBuffer commandBuffer -- > , VkQueryPool queryPool -- > , uint32_t firstQuery -- > , uint32_t queryCount -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdResetQueryPool vkCmdResetQueryPool registry at www.khronos.org> type HS_vkCmdResetQueryPool = VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ firstQuery -> Word32 -- ^ queryCount -> IO () type PFN_vkCmdResetQueryPool = FunPtr HS_vkCmdResetQueryPool foreign import ccall unsafe "dynamic" unwrapVkCmdResetQueryPoolUnsafe :: PFN_vkCmdResetQueryPool -> HS_vkCmdResetQueryPool foreign import ccall safe "dynamic" unwrapVkCmdResetQueryPoolSafe :: PFN_vkCmdResetQueryPool -> HS_vkCmdResetQueryPool instance VulkanProc "vkCmdResetQueryPool" where type VkProcType "vkCmdResetQueryPool" = HS_vkCmdResetQueryPool vkProcSymbol = _VkCmdResetQueryPool {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdResetQueryPoolUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdResetQueryPoolSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdWriteTimestamp :: CString pattern VkCmdWriteTimestamp <- (is_VkCmdWriteTimestamp -> True) where VkCmdWriteTimestamp = _VkCmdWriteTimestamp {-# INLINE _VkCmdWriteTimestamp #-} _VkCmdWriteTimestamp :: CString _VkCmdWriteTimestamp = Ptr "vkCmdWriteTimestamp\NUL"# {-# INLINE is_VkCmdWriteTimestamp #-} is_VkCmdWriteTimestamp :: CString -> Bool is_VkCmdWriteTimestamp = (EQ ==) . cmpCStrings _VkCmdWriteTimestamp type VkCmdWriteTimestamp = "vkCmdWriteTimestamp" -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- Pipeline: @transfer@ -- -- > void vkCmdWriteTimestamp -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineStageFlagBits pipelineStage -- > , VkQueryPool queryPool -- > , uint32_t query -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdWriteTimestamp vkCmdWriteTimestamp registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdWriteTimestamp <- vkGetInstanceProc @VkCmdWriteTimestamp vkInstance -- -- or less efficient: -- -- > myCmdWriteTimestamp <- vkGetProc @VkCmdWriteTimestamp -- -- __Note:__ @vkCmdWriteTimestampUnsafe@ and @vkCmdWriteTimestampSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdWriteTimestamp@ is an alias -- of @vkCmdWriteTimestampUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdWriteTimestampSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdWriteTimestamp" vkCmdWriteTimestampUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineStageFlagBits -- ^ pipelineStage -> VkQueryPool -- ^ queryPool -> Word32 -- ^ query -> IO () #else vkCmdWriteTimestampUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineStageFlagBits -- ^ pipelineStage -> VkQueryPool -- ^ queryPool -> Word32 -- ^ query -> IO () vkCmdWriteTimestampUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdWriteTimestamp) {-# NOINLINE vkCmdWriteTimestampUnsafe #-} #endif -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- Pipeline: @transfer@ -- -- > void vkCmdWriteTimestamp -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineStageFlagBits pipelineStage -- > , VkQueryPool queryPool -- > , uint32_t query -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdWriteTimestamp vkCmdWriteTimestamp registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdWriteTimestamp <- vkGetInstanceProc @VkCmdWriteTimestamp vkInstance -- -- or less efficient: -- -- > myCmdWriteTimestamp <- vkGetProc @VkCmdWriteTimestamp -- -- __Note:__ @vkCmdWriteTimestampUnsafe@ and @vkCmdWriteTimestampSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdWriteTimestamp@ is an alias -- of @vkCmdWriteTimestampUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdWriteTimestampSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdWriteTimestamp" vkCmdWriteTimestampSafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineStageFlagBits -- ^ pipelineStage -> VkQueryPool -- ^ queryPool -> Word32 -- ^ query -> IO () #else vkCmdWriteTimestampSafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineStageFlagBits -- ^ pipelineStage -> VkQueryPool -- ^ queryPool -> Word32 -- ^ query -> IO () vkCmdWriteTimestampSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdWriteTimestamp) {-# NOINLINE vkCmdWriteTimestampSafe #-} #endif -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- Pipeline: @transfer@ -- -- > void vkCmdWriteTimestamp -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineStageFlagBits pipelineStage -- > , VkQueryPool queryPool -- > , uint32_t query -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdWriteTimestamp vkCmdWriteTimestamp registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdWriteTimestamp <- vkGetInstanceProc @VkCmdWriteTimestamp vkInstance -- -- or less efficient: -- -- > myCmdWriteTimestamp <- vkGetProc @VkCmdWriteTimestamp -- -- __Note:__ @vkCmdWriteTimestampUnsafe@ and @vkCmdWriteTimestampSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdWriteTimestamp@ is an alias -- of @vkCmdWriteTimestampUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdWriteTimestampSafe@. -- vkCmdWriteTimestamp :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineStageFlagBits -- ^ pipelineStage -> VkQueryPool -- ^ queryPool -> Word32 -- ^ query -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdWriteTimestamp = vkCmdWriteTimestampUnsafe #else vkCmdWriteTimestamp = vkCmdWriteTimestampSafe #endif {-# INLINE vkCmdWriteTimestamp #-} -- | Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- Pipeline: @transfer@ -- -- > void vkCmdWriteTimestamp -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineStageFlagBits pipelineStage -- > , VkQueryPool queryPool -- > , uint32_t query -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdWriteTimestamp vkCmdWriteTimestamp registry at www.khronos.org> type HS_vkCmdWriteTimestamp = VkCommandBuffer -- ^ commandBuffer -> VkPipelineStageFlagBits -- ^ pipelineStage -> VkQueryPool -- ^ queryPool -> Word32 -- ^ query -> IO () type PFN_vkCmdWriteTimestamp = FunPtr HS_vkCmdWriteTimestamp foreign import ccall unsafe "dynamic" unwrapVkCmdWriteTimestampUnsafe :: PFN_vkCmdWriteTimestamp -> HS_vkCmdWriteTimestamp foreign import ccall safe "dynamic" unwrapVkCmdWriteTimestampSafe :: PFN_vkCmdWriteTimestamp -> HS_vkCmdWriteTimestamp instance VulkanProc "vkCmdWriteTimestamp" where type VkProcType "vkCmdWriteTimestamp" = HS_vkCmdWriteTimestamp vkProcSymbol = _VkCmdWriteTimestamp {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdWriteTimestampUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdWriteTimestampSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdCopyQueryPoolResults :: CString pattern VkCmdCopyQueryPoolResults <- (is_VkCmdCopyQueryPoolResults -> True) where VkCmdCopyQueryPoolResults = _VkCmdCopyQueryPoolResults {-# INLINE _VkCmdCopyQueryPoolResults #-} _VkCmdCopyQueryPoolResults :: CString _VkCmdCopyQueryPoolResults = Ptr "vkCmdCopyQueryPoolResults\NUL"# {-# INLINE is_VkCmdCopyQueryPoolResults #-} is_VkCmdCopyQueryPoolResults :: CString -> Bool is_VkCmdCopyQueryPoolResults = (EQ ==) . cmpCStrings _VkCmdCopyQueryPoolResults type VkCmdCopyQueryPoolResults = "vkCmdCopyQueryPoolResults" -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyQueryPoolResults -- > ( VkCommandBuffer commandBuffer -- > , VkQueryPool queryPool -- > , uint32_t firstQuery -- > , uint32_t queryCount -- > , VkBuffer dstBuffer -- > , VkDeviceSize dstOffset -- > , VkDeviceSize stride -- > , VkQueryResultFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdCopyQueryPoolResults <- vkGetInstanceProc @VkCmdCopyQueryPoolResults vkInstance -- -- or less efficient: -- -- > myCmdCopyQueryPoolResults <- vkGetProc @VkCmdCopyQueryPoolResults -- -- __Note:__ @vkCmdCopyQueryPoolResultsUnsafe@ and @vkCmdCopyQueryPoolResultsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdCopyQueryPoolResults@ is an alias -- of @vkCmdCopyQueryPoolResultsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdCopyQueryPoolResultsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdCopyQueryPoolResults" vkCmdCopyQueryPoolResultsUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ firstQuery -> Word32 -- ^ queryCount -> VkBuffer -- ^ dstBuffer -> VkDeviceSize -- ^ dstOffset -> VkDeviceSize -- ^ stride -> VkQueryResultFlags -- ^ flags -> IO () #else vkCmdCopyQueryPoolResultsUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ firstQuery -> Word32 -- ^ queryCount -> VkBuffer -- ^ dstBuffer -> VkDeviceSize -- ^ dstOffset -> VkDeviceSize -- ^ stride -> VkQueryResultFlags -- ^ flags -> IO () vkCmdCopyQueryPoolResultsUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdCopyQueryPoolResults) {-# NOINLINE vkCmdCopyQueryPoolResultsUnsafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyQueryPoolResults -- > ( VkCommandBuffer commandBuffer -- > , VkQueryPool queryPool -- > , uint32_t firstQuery -- > , uint32_t queryCount -- > , VkBuffer dstBuffer -- > , VkDeviceSize dstOffset -- > , VkDeviceSize stride -- > , VkQueryResultFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdCopyQueryPoolResults <- vkGetInstanceProc @VkCmdCopyQueryPoolResults vkInstance -- -- or less efficient: -- -- > myCmdCopyQueryPoolResults <- vkGetProc @VkCmdCopyQueryPoolResults -- -- __Note:__ @vkCmdCopyQueryPoolResultsUnsafe@ and @vkCmdCopyQueryPoolResultsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdCopyQueryPoolResults@ is an alias -- of @vkCmdCopyQueryPoolResultsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdCopyQueryPoolResultsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdCopyQueryPoolResults" vkCmdCopyQueryPoolResultsSafe :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ firstQuery -> Word32 -- ^ queryCount -> VkBuffer -- ^ dstBuffer -> VkDeviceSize -- ^ dstOffset -> VkDeviceSize -- ^ stride -> VkQueryResultFlags -- ^ flags -> IO () #else vkCmdCopyQueryPoolResultsSafe :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ firstQuery -> Word32 -- ^ queryCount -> VkBuffer -- ^ dstBuffer -> VkDeviceSize -- ^ dstOffset -> VkDeviceSize -- ^ stride -> VkQueryResultFlags -- ^ flags -> IO () vkCmdCopyQueryPoolResultsSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdCopyQueryPoolResults) {-# NOINLINE vkCmdCopyQueryPoolResultsSafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyQueryPoolResults -- > ( VkCommandBuffer commandBuffer -- > , VkQueryPool queryPool -- > , uint32_t firstQuery -- > , uint32_t queryCount -- > , VkBuffer dstBuffer -- > , VkDeviceSize dstOffset -- > , VkDeviceSize stride -- > , VkQueryResultFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdCopyQueryPoolResults <- vkGetInstanceProc @VkCmdCopyQueryPoolResults vkInstance -- -- or less efficient: -- -- > myCmdCopyQueryPoolResults <- vkGetProc @VkCmdCopyQueryPoolResults -- -- __Note:__ @vkCmdCopyQueryPoolResultsUnsafe@ and @vkCmdCopyQueryPoolResultsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdCopyQueryPoolResults@ is an alias -- of @vkCmdCopyQueryPoolResultsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdCopyQueryPoolResultsSafe@. -- vkCmdCopyQueryPoolResults :: VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ firstQuery -> Word32 -- ^ queryCount -> VkBuffer -- ^ dstBuffer -> VkDeviceSize -- ^ dstOffset -> VkDeviceSize -- ^ stride -> VkQueryResultFlags -- ^ flags -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdCopyQueryPoolResults = vkCmdCopyQueryPoolResultsUnsafe #else vkCmdCopyQueryPoolResults = vkCmdCopyQueryPoolResultsSafe #endif {-# INLINE vkCmdCopyQueryPoolResults #-} -- | Queues: 'graphics', 'compute'. -- -- Renderpass: @outside@ -- -- Pipeline: @transfer@ -- -- > void vkCmdCopyQueryPoolResults -- > ( VkCommandBuffer commandBuffer -- > , VkQueryPool queryPool -- > , uint32_t firstQuery -- > , uint32_t queryCount -- > , VkBuffer dstBuffer -- > , VkDeviceSize dstOffset -- > , VkDeviceSize stride -- > , VkQueryResultFlags flags -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults registry at www.khronos.org> type HS_vkCmdCopyQueryPoolResults = VkCommandBuffer -- ^ commandBuffer -> VkQueryPool -- ^ queryPool -> Word32 -- ^ firstQuery -> Word32 -- ^ queryCount -> VkBuffer -- ^ dstBuffer -> VkDeviceSize -- ^ dstOffset -> VkDeviceSize -- ^ stride -> VkQueryResultFlags -- ^ flags -> IO () type PFN_vkCmdCopyQueryPoolResults = FunPtr HS_vkCmdCopyQueryPoolResults foreign import ccall unsafe "dynamic" unwrapVkCmdCopyQueryPoolResultsUnsafe :: PFN_vkCmdCopyQueryPoolResults -> HS_vkCmdCopyQueryPoolResults foreign import ccall safe "dynamic" unwrapVkCmdCopyQueryPoolResultsSafe :: PFN_vkCmdCopyQueryPoolResults -> HS_vkCmdCopyQueryPoolResults instance VulkanProc "vkCmdCopyQueryPoolResults" where type VkProcType "vkCmdCopyQueryPoolResults" = HS_vkCmdCopyQueryPoolResults vkProcSymbol = _VkCmdCopyQueryPoolResults {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdCopyQueryPoolResultsUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdCopyQueryPoolResultsSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdPushConstants :: CString pattern VkCmdPushConstants <- (is_VkCmdPushConstants -> True) where VkCmdPushConstants = _VkCmdPushConstants {-# INLINE _VkCmdPushConstants #-} _VkCmdPushConstants :: CString _VkCmdPushConstants = Ptr "vkCmdPushConstants\NUL"# {-# INLINE is_VkCmdPushConstants #-} is_VkCmdPushConstants :: CString -> Bool is_VkCmdPushConstants = (EQ ==) . cmpCStrings _VkCmdPushConstants type VkCmdPushConstants = "vkCmdPushConstants" -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdPushConstants -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineLayout layout -- > , VkShaderStageFlags stageFlags -- > , uint32_t offset -- > , uint32_t size -- > , const void* pValues -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdPushConstants vkCmdPushConstants registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdPushConstants <- vkGetInstanceProc @VkCmdPushConstants vkInstance -- -- or less efficient: -- -- > myCmdPushConstants <- vkGetProc @VkCmdPushConstants -- -- __Note:__ @vkCmdPushConstantsUnsafe@ and @vkCmdPushConstantsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdPushConstants@ is an alias -- of @vkCmdPushConstantsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdPushConstantsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdPushConstants" vkCmdPushConstantsUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineLayout -- ^ layout -> VkShaderStageFlags -- ^ stageFlags -> Word32 -- ^ offset -> Word32 -- ^ size -> Ptr Void -- ^ pValues -> IO () #else vkCmdPushConstantsUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineLayout -- ^ layout -> VkShaderStageFlags -- ^ stageFlags -> Word32 -- ^ offset -> Word32 -- ^ size -> Ptr Void -- ^ pValues -> IO () vkCmdPushConstantsUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdPushConstants) {-# NOINLINE vkCmdPushConstantsUnsafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdPushConstants -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineLayout layout -- > , VkShaderStageFlags stageFlags -- > , uint32_t offset -- > , uint32_t size -- > , const void* pValues -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdPushConstants vkCmdPushConstants registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdPushConstants <- vkGetInstanceProc @VkCmdPushConstants vkInstance -- -- or less efficient: -- -- > myCmdPushConstants <- vkGetProc @VkCmdPushConstants -- -- __Note:__ @vkCmdPushConstantsUnsafe@ and @vkCmdPushConstantsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdPushConstants@ is an alias -- of @vkCmdPushConstantsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdPushConstantsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdPushConstants" vkCmdPushConstantsSafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineLayout -- ^ layout -> VkShaderStageFlags -- ^ stageFlags -> Word32 -- ^ offset -> Word32 -- ^ size -> Ptr Void -- ^ pValues -> IO () #else vkCmdPushConstantsSafe :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineLayout -- ^ layout -> VkShaderStageFlags -- ^ stageFlags -> Word32 -- ^ offset -> Word32 -- ^ size -> Ptr Void -- ^ pValues -> IO () vkCmdPushConstantsSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdPushConstants) {-# NOINLINE vkCmdPushConstantsSafe #-} #endif -- | -- Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdPushConstants -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineLayout layout -- > , VkShaderStageFlags stageFlags -- > , uint32_t offset -- > , uint32_t size -- > , const void* pValues -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdPushConstants vkCmdPushConstants registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdPushConstants <- vkGetInstanceProc @VkCmdPushConstants vkInstance -- -- or less efficient: -- -- > myCmdPushConstants <- vkGetProc @VkCmdPushConstants -- -- __Note:__ @vkCmdPushConstantsUnsafe@ and @vkCmdPushConstantsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdPushConstants@ is an alias -- of @vkCmdPushConstantsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdPushConstantsSafe@. -- vkCmdPushConstants :: VkCommandBuffer -- ^ commandBuffer -> VkPipelineLayout -- ^ layout -> VkShaderStageFlags -- ^ stageFlags -> Word32 -- ^ offset -> Word32 -- ^ size -> Ptr Void -- ^ pValues -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdPushConstants = vkCmdPushConstantsUnsafe #else vkCmdPushConstants = vkCmdPushConstantsSafe #endif {-# INLINE vkCmdPushConstants #-} -- | Queues: 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdPushConstants -- > ( VkCommandBuffer commandBuffer -- > , VkPipelineLayout layout -- > , VkShaderStageFlags stageFlags -- > , uint32_t offset -- > , uint32_t size -- > , const void* pValues -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdPushConstants vkCmdPushConstants registry at www.khronos.org> type HS_vkCmdPushConstants = VkCommandBuffer -- ^ commandBuffer -> VkPipelineLayout -- ^ layout -> VkShaderStageFlags -- ^ stageFlags -> Word32 -- ^ offset -> Word32 -- ^ size -> Ptr Void -- ^ pValues -> IO () type PFN_vkCmdPushConstants = FunPtr HS_vkCmdPushConstants foreign import ccall unsafe "dynamic" unwrapVkCmdPushConstantsUnsafe :: PFN_vkCmdPushConstants -> HS_vkCmdPushConstants foreign import ccall safe "dynamic" unwrapVkCmdPushConstantsSafe :: PFN_vkCmdPushConstants -> HS_vkCmdPushConstants instance VulkanProc "vkCmdPushConstants" where type VkProcType "vkCmdPushConstants" = HS_vkCmdPushConstants vkProcSymbol = _VkCmdPushConstants {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdPushConstantsUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdPushConstantsSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdBeginRenderPass :: CString pattern VkCmdBeginRenderPass <- (is_VkCmdBeginRenderPass -> True) where VkCmdBeginRenderPass = _VkCmdBeginRenderPass {-# INLINE _VkCmdBeginRenderPass #-} _VkCmdBeginRenderPass :: CString _VkCmdBeginRenderPass = Ptr "vkCmdBeginRenderPass\NUL"# {-# INLINE is_VkCmdBeginRenderPass #-} is_VkCmdBeginRenderPass :: CString -> Bool is_VkCmdBeginRenderPass = (EQ ==) . cmpCStrings _VkCmdBeginRenderPass type VkCmdBeginRenderPass = "vkCmdBeginRenderPass" -- | -- Queues: 'graphics'. -- -- Renderpass: @outside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdBeginRenderPass -- > ( VkCommandBuffer commandBuffer -- > , const VkRenderPassBeginInfo* pRenderPassBegin -- > , VkSubpassContents contents -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBeginRenderPass vkCmdBeginRenderPass registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBeginRenderPass <- vkGetInstanceProc @VkCmdBeginRenderPass vkInstance -- -- or less efficient: -- -- > myCmdBeginRenderPass <- vkGetProc @VkCmdBeginRenderPass -- -- __Note:__ @vkCmdBeginRenderPassUnsafe@ and @vkCmdBeginRenderPassSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBeginRenderPass@ is an alias -- of @vkCmdBeginRenderPassUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBeginRenderPassSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdBeginRenderPass" vkCmdBeginRenderPassUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Ptr VkRenderPassBeginInfo -- ^ pRenderPassBegin -> VkSubpassContents -- ^ contents -> IO () #else vkCmdBeginRenderPassUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Ptr VkRenderPassBeginInfo -- ^ pRenderPassBegin -> VkSubpassContents -- ^ contents -> IO () vkCmdBeginRenderPassUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdBeginRenderPass) {-# NOINLINE vkCmdBeginRenderPassUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @outside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdBeginRenderPass -- > ( VkCommandBuffer commandBuffer -- > , const VkRenderPassBeginInfo* pRenderPassBegin -- > , VkSubpassContents contents -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBeginRenderPass vkCmdBeginRenderPass registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBeginRenderPass <- vkGetInstanceProc @VkCmdBeginRenderPass vkInstance -- -- or less efficient: -- -- > myCmdBeginRenderPass <- vkGetProc @VkCmdBeginRenderPass -- -- __Note:__ @vkCmdBeginRenderPassUnsafe@ and @vkCmdBeginRenderPassSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBeginRenderPass@ is an alias -- of @vkCmdBeginRenderPassUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBeginRenderPassSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdBeginRenderPass" vkCmdBeginRenderPassSafe :: VkCommandBuffer -- ^ commandBuffer -> Ptr VkRenderPassBeginInfo -- ^ pRenderPassBegin -> VkSubpassContents -- ^ contents -> IO () #else vkCmdBeginRenderPassSafe :: VkCommandBuffer -- ^ commandBuffer -> Ptr VkRenderPassBeginInfo -- ^ pRenderPassBegin -> VkSubpassContents -- ^ contents -> IO () vkCmdBeginRenderPassSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdBeginRenderPass) {-# NOINLINE vkCmdBeginRenderPassSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @outside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdBeginRenderPass -- > ( VkCommandBuffer commandBuffer -- > , const VkRenderPassBeginInfo* pRenderPassBegin -- > , VkSubpassContents contents -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBeginRenderPass vkCmdBeginRenderPass registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdBeginRenderPass <- vkGetInstanceProc @VkCmdBeginRenderPass vkInstance -- -- or less efficient: -- -- > myCmdBeginRenderPass <- vkGetProc @VkCmdBeginRenderPass -- -- __Note:__ @vkCmdBeginRenderPassUnsafe@ and @vkCmdBeginRenderPassSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdBeginRenderPass@ is an alias -- of @vkCmdBeginRenderPassUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdBeginRenderPassSafe@. -- vkCmdBeginRenderPass :: VkCommandBuffer -- ^ commandBuffer -> Ptr VkRenderPassBeginInfo -- ^ pRenderPassBegin -> VkSubpassContents -- ^ contents -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdBeginRenderPass = vkCmdBeginRenderPassUnsafe #else vkCmdBeginRenderPass = vkCmdBeginRenderPassSafe #endif {-# INLINE vkCmdBeginRenderPass #-} -- | Queues: 'graphics'. -- -- Renderpass: @outside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdBeginRenderPass -- > ( VkCommandBuffer commandBuffer -- > , const VkRenderPassBeginInfo* pRenderPassBegin -- > , VkSubpassContents contents -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdBeginRenderPass vkCmdBeginRenderPass registry at www.khronos.org> type HS_vkCmdBeginRenderPass = VkCommandBuffer -- ^ commandBuffer -> Ptr VkRenderPassBeginInfo -- ^ pRenderPassBegin -> VkSubpassContents -- ^ contents -> IO () type PFN_vkCmdBeginRenderPass = FunPtr HS_vkCmdBeginRenderPass foreign import ccall unsafe "dynamic" unwrapVkCmdBeginRenderPassUnsafe :: PFN_vkCmdBeginRenderPass -> HS_vkCmdBeginRenderPass foreign import ccall safe "dynamic" unwrapVkCmdBeginRenderPassSafe :: PFN_vkCmdBeginRenderPass -> HS_vkCmdBeginRenderPass instance VulkanProc "vkCmdBeginRenderPass" where type VkProcType "vkCmdBeginRenderPass" = HS_vkCmdBeginRenderPass vkProcSymbol = _VkCmdBeginRenderPass {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdBeginRenderPassUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdBeginRenderPassSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdNextSubpass :: CString pattern VkCmdNextSubpass <- (is_VkCmdNextSubpass -> True) where VkCmdNextSubpass = _VkCmdNextSubpass {-# INLINE _VkCmdNextSubpass #-} _VkCmdNextSubpass :: CString _VkCmdNextSubpass = Ptr "vkCmdNextSubpass\NUL"# {-# INLINE is_VkCmdNextSubpass #-} is_VkCmdNextSubpass :: CString -> Bool is_VkCmdNextSubpass = (EQ ==) . cmpCStrings _VkCmdNextSubpass type VkCmdNextSubpass = "vkCmdNextSubpass" -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdNextSubpass -- > ( VkCommandBuffer commandBuffer -- > , VkSubpassContents contents -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdNextSubpass vkCmdNextSubpass registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdNextSubpass <- vkGetInstanceProc @VkCmdNextSubpass vkInstance -- -- or less efficient: -- -- > myCmdNextSubpass <- vkGetProc @VkCmdNextSubpass -- -- __Note:__ @vkCmdNextSubpassUnsafe@ and @vkCmdNextSubpassSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdNextSubpass@ is an alias -- of @vkCmdNextSubpassUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdNextSubpassSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdNextSubpass" vkCmdNextSubpassUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkSubpassContents -- ^ contents -> IO () #else vkCmdNextSubpassUnsafe :: VkCommandBuffer -- ^ commandBuffer -> VkSubpassContents -- ^ contents -> IO () vkCmdNextSubpassUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdNextSubpass) {-# NOINLINE vkCmdNextSubpassUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdNextSubpass -- > ( VkCommandBuffer commandBuffer -- > , VkSubpassContents contents -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdNextSubpass vkCmdNextSubpass registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdNextSubpass <- vkGetInstanceProc @VkCmdNextSubpass vkInstance -- -- or less efficient: -- -- > myCmdNextSubpass <- vkGetProc @VkCmdNextSubpass -- -- __Note:__ @vkCmdNextSubpassUnsafe@ and @vkCmdNextSubpassSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdNextSubpass@ is an alias -- of @vkCmdNextSubpassUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdNextSubpassSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdNextSubpass" vkCmdNextSubpassSafe :: VkCommandBuffer -- ^ commandBuffer -> VkSubpassContents -- ^ contents -> IO () #else vkCmdNextSubpassSafe :: VkCommandBuffer -- ^ commandBuffer -> VkSubpassContents -- ^ contents -> IO () vkCmdNextSubpassSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdNextSubpass) {-# NOINLINE vkCmdNextSubpassSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdNextSubpass -- > ( VkCommandBuffer commandBuffer -- > , VkSubpassContents contents -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdNextSubpass vkCmdNextSubpass registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdNextSubpass <- vkGetInstanceProc @VkCmdNextSubpass vkInstance -- -- or less efficient: -- -- > myCmdNextSubpass <- vkGetProc @VkCmdNextSubpass -- -- __Note:__ @vkCmdNextSubpassUnsafe@ and @vkCmdNextSubpassSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdNextSubpass@ is an alias -- of @vkCmdNextSubpassUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdNextSubpassSafe@. -- vkCmdNextSubpass :: VkCommandBuffer -- ^ commandBuffer -> VkSubpassContents -- ^ contents -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdNextSubpass = vkCmdNextSubpassUnsafe #else vkCmdNextSubpass = vkCmdNextSubpassSafe #endif {-# INLINE vkCmdNextSubpass #-} -- | Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdNextSubpass -- > ( VkCommandBuffer commandBuffer -- > , VkSubpassContents contents -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdNextSubpass vkCmdNextSubpass registry at www.khronos.org> type HS_vkCmdNextSubpass = VkCommandBuffer -- ^ commandBuffer -> VkSubpassContents -- ^ contents -> IO () type PFN_vkCmdNextSubpass = FunPtr HS_vkCmdNextSubpass foreign import ccall unsafe "dynamic" unwrapVkCmdNextSubpassUnsafe :: PFN_vkCmdNextSubpass -> HS_vkCmdNextSubpass foreign import ccall safe "dynamic" unwrapVkCmdNextSubpassSafe :: PFN_vkCmdNextSubpass -> HS_vkCmdNextSubpass instance VulkanProc "vkCmdNextSubpass" where type VkProcType "vkCmdNextSubpass" = HS_vkCmdNextSubpass vkProcSymbol = _VkCmdNextSubpass {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdNextSubpassUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdNextSubpassSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdEndRenderPass :: CString pattern VkCmdEndRenderPass <- (is_VkCmdEndRenderPass -> True) where VkCmdEndRenderPass = _VkCmdEndRenderPass {-# INLINE _VkCmdEndRenderPass #-} _VkCmdEndRenderPass :: CString _VkCmdEndRenderPass = Ptr "vkCmdEndRenderPass\NUL"# {-# INLINE is_VkCmdEndRenderPass #-} is_VkCmdEndRenderPass :: CString -> Bool is_VkCmdEndRenderPass = (EQ ==) . cmpCStrings _VkCmdEndRenderPass type VkCmdEndRenderPass = "vkCmdEndRenderPass" -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdEndRenderPass -- > ( VkCommandBuffer commandBuffer -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdEndRenderPass vkCmdEndRenderPass registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdEndRenderPass <- vkGetInstanceProc @VkCmdEndRenderPass vkInstance -- -- or less efficient: -- -- > myCmdEndRenderPass <- vkGetProc @VkCmdEndRenderPass -- -- __Note:__ @vkCmdEndRenderPassUnsafe@ and @vkCmdEndRenderPassSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdEndRenderPass@ is an alias -- of @vkCmdEndRenderPassUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdEndRenderPassSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdEndRenderPass" vkCmdEndRenderPassUnsafe :: VkCommandBuffer -- ^ commandBuffer -> IO () #else vkCmdEndRenderPassUnsafe :: VkCommandBuffer -- ^ commandBuffer -> IO () vkCmdEndRenderPassUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdEndRenderPass) {-# NOINLINE vkCmdEndRenderPassUnsafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdEndRenderPass -- > ( VkCommandBuffer commandBuffer -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdEndRenderPass vkCmdEndRenderPass registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdEndRenderPass <- vkGetInstanceProc @VkCmdEndRenderPass vkInstance -- -- or less efficient: -- -- > myCmdEndRenderPass <- vkGetProc @VkCmdEndRenderPass -- -- __Note:__ @vkCmdEndRenderPassUnsafe@ and @vkCmdEndRenderPassSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdEndRenderPass@ is an alias -- of @vkCmdEndRenderPassUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdEndRenderPassSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdEndRenderPass" vkCmdEndRenderPassSafe :: VkCommandBuffer -- ^ commandBuffer -> IO () #else vkCmdEndRenderPassSafe :: VkCommandBuffer -- ^ commandBuffer -> IO () vkCmdEndRenderPassSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdEndRenderPass) {-# NOINLINE vkCmdEndRenderPassSafe #-} #endif -- | -- Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdEndRenderPass -- > ( VkCommandBuffer commandBuffer -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdEndRenderPass vkCmdEndRenderPass registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdEndRenderPass <- vkGetInstanceProc @VkCmdEndRenderPass vkInstance -- -- or less efficient: -- -- > myCmdEndRenderPass <- vkGetProc @VkCmdEndRenderPass -- -- __Note:__ @vkCmdEndRenderPassUnsafe@ and @vkCmdEndRenderPassSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdEndRenderPass@ is an alias -- of @vkCmdEndRenderPassUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdEndRenderPassSafe@. -- vkCmdEndRenderPass :: VkCommandBuffer -- ^ commandBuffer -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdEndRenderPass = vkCmdEndRenderPassUnsafe #else vkCmdEndRenderPass = vkCmdEndRenderPassSafe #endif {-# INLINE vkCmdEndRenderPass #-} -- | Queues: 'graphics'. -- -- Renderpass: @inside@ -- -- Pipeline: @graphics@ -- -- > void vkCmdEndRenderPass -- > ( VkCommandBuffer commandBuffer -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdEndRenderPass vkCmdEndRenderPass registry at www.khronos.org> type HS_vkCmdEndRenderPass = VkCommandBuffer -- ^ commandBuffer -> IO () type PFN_vkCmdEndRenderPass = FunPtr HS_vkCmdEndRenderPass foreign import ccall unsafe "dynamic" unwrapVkCmdEndRenderPassUnsafe :: PFN_vkCmdEndRenderPass -> HS_vkCmdEndRenderPass foreign import ccall safe "dynamic" unwrapVkCmdEndRenderPassSafe :: PFN_vkCmdEndRenderPass -> HS_vkCmdEndRenderPass instance VulkanProc "vkCmdEndRenderPass" where type VkProcType "vkCmdEndRenderPass" = HS_vkCmdEndRenderPass vkProcSymbol = _VkCmdEndRenderPass {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdEndRenderPassUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdEndRenderPassSafe {-# INLINE unwrapVkProcPtrSafe #-} pattern VkCmdExecuteCommands :: CString pattern VkCmdExecuteCommands <- (is_VkCmdExecuteCommands -> True) where VkCmdExecuteCommands = _VkCmdExecuteCommands {-# INLINE _VkCmdExecuteCommands #-} _VkCmdExecuteCommands :: CString _VkCmdExecuteCommands = Ptr "vkCmdExecuteCommands\NUL"# {-# INLINE is_VkCmdExecuteCommands #-} is_VkCmdExecuteCommands :: CString -> Bool is_VkCmdExecuteCommands = (EQ ==) . cmpCStrings _VkCmdExecuteCommands type VkCmdExecuteCommands = "vkCmdExecuteCommands" -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdExecuteCommands -- > ( VkCommandBuffer commandBuffer -- > , uint32_t commandBufferCount -- > , const VkCommandBuffer* pCommandBuffers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdExecuteCommands vkCmdExecuteCommands registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdExecuteCommands <- vkGetInstanceProc @VkCmdExecuteCommands vkInstance -- -- or less efficient: -- -- > myCmdExecuteCommands <- vkGetProc @VkCmdExecuteCommands -- -- __Note:__ @vkCmdExecuteCommandsUnsafe@ and @vkCmdExecuteCommandsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdExecuteCommands@ is an alias -- of @vkCmdExecuteCommandsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdExecuteCommandsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall unsafe "vkCmdExecuteCommands" vkCmdExecuteCommandsUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ commandBufferCount -> Ptr VkCommandBuffer -- ^ pCommandBuffers -> IO () #else vkCmdExecuteCommandsUnsafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ commandBufferCount -> Ptr VkCommandBuffer -- ^ pCommandBuffers -> IO () vkCmdExecuteCommandsUnsafe = unsafeDupablePerformIO (vkGetProcUnsafe @VkCmdExecuteCommands) {-# NOINLINE vkCmdExecuteCommandsUnsafe #-} #endif -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdExecuteCommands -- > ( VkCommandBuffer commandBuffer -- > , uint32_t commandBufferCount -- > , const VkCommandBuffer* pCommandBuffers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdExecuteCommands vkCmdExecuteCommands registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdExecuteCommands <- vkGetInstanceProc @VkCmdExecuteCommands vkInstance -- -- or less efficient: -- -- > myCmdExecuteCommands <- vkGetProc @VkCmdExecuteCommands -- -- __Note:__ @vkCmdExecuteCommandsUnsafe@ and @vkCmdExecuteCommandsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdExecuteCommands@ is an alias -- of @vkCmdExecuteCommandsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdExecuteCommandsSafe@. -- -- #ifdef NATIVE_FFI_VK_VERSION_1_0 foreign import ccall safe "vkCmdExecuteCommands" vkCmdExecuteCommandsSafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ commandBufferCount -> Ptr VkCommandBuffer -- ^ pCommandBuffers -> IO () #else vkCmdExecuteCommandsSafe :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ commandBufferCount -> Ptr VkCommandBuffer -- ^ pCommandBuffers -> IO () vkCmdExecuteCommandsSafe = unsafeDupablePerformIO (vkGetProcSafe @VkCmdExecuteCommands) {-# NOINLINE vkCmdExecuteCommandsSafe #-} #endif -- | -- Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdExecuteCommands -- > ( VkCommandBuffer commandBuffer -- > , uint32_t commandBufferCount -- > , const VkCommandBuffer* pCommandBuffers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdExecuteCommands vkCmdExecuteCommands registry at www.khronos.org> -- -- __Note:__ When @useNativeFFI-1-0@ 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: -- -- > myCmdExecuteCommands <- vkGetInstanceProc @VkCmdExecuteCommands vkInstance -- -- or less efficient: -- -- > myCmdExecuteCommands <- vkGetProc @VkCmdExecuteCommands -- -- __Note:__ @vkCmdExecuteCommandsUnsafe@ and @vkCmdExecuteCommandsSafe@ are the @unsafe@ and @safe@ -- FFI imports of this function, respectively. @vkCmdExecuteCommands@ is an alias -- of @vkCmdExecuteCommandsUnsafe@ when the @useUnsafeFFIDefault@ cabal flag -- is enabled; otherwise, it is an alias of @vkCmdExecuteCommandsSafe@. -- vkCmdExecuteCommands :: VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ commandBufferCount -> Ptr VkCommandBuffer -- ^ pCommandBuffers -> IO () #ifdef UNSAFE_FFI_DEFAULT vkCmdExecuteCommands = vkCmdExecuteCommandsUnsafe #else vkCmdExecuteCommands = vkCmdExecuteCommandsSafe #endif {-# INLINE vkCmdExecuteCommands #-} -- | Queues: 'transfer', 'graphics', 'compute'. -- -- Renderpass: @both@ -- -- > void vkCmdExecuteCommands -- > ( VkCommandBuffer commandBuffer -- > , uint32_t commandBufferCount -- > , const VkCommandBuffer* pCommandBuffers -- > ) -- -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#vkCmdExecuteCommands vkCmdExecuteCommands registry at www.khronos.org> type HS_vkCmdExecuteCommands = VkCommandBuffer -- ^ commandBuffer -> Word32 -- ^ commandBufferCount -> Ptr VkCommandBuffer -- ^ pCommandBuffers -> IO () type PFN_vkCmdExecuteCommands = FunPtr HS_vkCmdExecuteCommands foreign import ccall unsafe "dynamic" unwrapVkCmdExecuteCommandsUnsafe :: PFN_vkCmdExecuteCommands -> HS_vkCmdExecuteCommands foreign import ccall safe "dynamic" unwrapVkCmdExecuteCommandsSafe :: PFN_vkCmdExecuteCommands -> HS_vkCmdExecuteCommands instance VulkanProc "vkCmdExecuteCommands" where type VkProcType "vkCmdExecuteCommands" = HS_vkCmdExecuteCommands vkProcSymbol = _VkCmdExecuteCommands {-# INLINE vkProcSymbol #-} unwrapVkProcPtrUnsafe = unwrapVkCmdExecuteCommandsUnsafe {-# INLINE unwrapVkProcPtrUnsafe #-} unwrapVkProcPtrSafe = unwrapVkCmdExecuteCommandsSafe {-# INLINE unwrapVkProcPtrSafe #-}