diff options
| -rw-r--r-- | include/vulkan/vulkan.hpp | 1447 | ||||
| -rw-r--r-- | include/vulkan/vulkan_win32.h | 6 | ||||
| -rw-r--r-- | registry/genvk.py | 10 |
3 files changed, 1451 insertions, 12 deletions
diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp index 342ab70..880c631 100644 --- a/include/vulkan/vulkan.hpp +++ b/include/vulkan/vulkan.hpp @@ -56,7 +56,7 @@ # define VULKAN_HPP_ASSERT assert #endif -static_assert( VK_HEADER_VERSION == 103 , "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 105 , "Wrong VK_HEADER_VERSION!" ); // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION @@ -437,6 +437,15 @@ namespace VULKAN_HPP_NAMESPACE template<typename ClassType> ClassType& get() { return static_cast<ClassType&>(*this);} + template<typename ClassTypeA, typename ClassTypeB, typename ...ClassTypes> + std::tuple<ClassTypeA, ClassTypeB, ClassTypes...> get() + { + return std::tuple_cat( + std::make_tuple(get<ClassTypeA>(),get<ClassTypeB>()), + std::make_tuple(get<ClassTypes>()...) + ); + } + private: template<typename List, typename X> void link() @@ -1077,6 +1086,13 @@ namespace VULKAN_HPP_NAMESPACE return ::vkResetCommandBuffer( commandBuffer, flags ); } +#ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkAcquireFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const + { + return ::vkAcquireFullScreenExclusiveModeEXT( device, swapchain ); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex ) const { return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex ); @@ -1544,6 +1560,13 @@ namespace VULKAN_HPP_NAMESPACE return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities ); } +#ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkGetDeviceGroupSurfacePresentModes2EXT( VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes ) const + { + return ::vkGetDeviceGroupSurfacePresentModes2EXT( device, pSurfaceInfo, pModes ); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + VkResult vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes ) const { return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes ); @@ -1805,6 +1828,13 @@ namespace VULKAN_HPP_NAMESPACE return ::vkRegisterObjectsNVX( device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices ); } +#ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkReleaseFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const + { + return ::vkReleaseFullScreenExclusiveModeEXT( device, swapchain ); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const { return ::vkResetCommandPool( device, commandPool, flags ); @@ -1825,6 +1855,11 @@ namespace VULKAN_HPP_NAMESPACE return ::vkResetFences( device, fenceCount, pFences ); } + void vkResetQueryPoolEXT( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const + { + return ::vkResetQueryPoolEXT( device, queryPool, firstQuery, queryCount ); + } + VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo ) const { return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo ); @@ -1935,6 +1970,13 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VK_USE_PLATFORM_METAL_EXT*/ +#ifdef VK_USE_PLATFORM_GGP + VkResult vkCreateStreamDescriptorSurfaceGGP( VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const + { + return ::vkCreateStreamDescriptorSurfaceGGP( instance, pCreateInfo, pAllocator, pSurface ); + } +#endif /*VK_USE_PLATFORM_GGP*/ + #ifdef VK_USE_PLATFORM_VI_NN VkResult vkCreateViSurfaceNN( VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const { @@ -2282,6 +2324,13 @@ namespace VULKAN_HPP_NAMESPACE return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats ); } +#ifdef VK_USE_PLATFORM_WIN32_KHR + VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes ) const + { + return ::vkGetPhysicalDeviceSurfacePresentModes2EXT( physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes ); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes ) const { return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes ); @@ -2371,6 +2420,11 @@ namespace VULKAN_HPP_NAMESPACE { return ::vkQueueWaitIdle( queue ); } + + void vkSetLocalDimmingAMD( VkSwapchainKHR swapChain, VkBool32 localDimmingEnable ) const + { + return ::vkSetLocalDimmingAMD( swapChain, localDimmingEnable ); + } }; struct AllocationCallbacks; @@ -2812,6 +2866,7 @@ namespace VULKAN_HPP_NAMESPACE eAdobergbNonlinearEXT = VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT, ePassThroughEXT = VK_COLOR_SPACE_PASS_THROUGH_EXT, eExtendedSrgbNonlinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT, + eDisplayNativeAMD = VK_COLOR_SPACE_DISPLAY_NATIVE_AMD, eVkColorspaceSrgbNonlinear = VK_COLORSPACE_SRGB_NONLINEAR_KHR }; @@ -2834,6 +2889,7 @@ namespace VULKAN_HPP_NAMESPACE case ColorSpaceKHR::eAdobergbNonlinearEXT : return "AdobergbNonlinearEXT"; case ColorSpaceKHR::ePassThroughEXT : return "PassThroughEXT"; case ColorSpaceKHR::eExtendedSrgbNonlinearEXT : return "ExtendedSrgbNonlinearEXT"; + case ColorSpaceKHR::eDisplayNativeAMD : return "DisplayNativeAMD"; default: return "invalid"; } } @@ -3214,7 +3270,8 @@ namespace VULKAN_HPP_NAMESPACE eImaginationProprietary = VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR, eQualcommProprietary = VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR, eArmProprietary = VK_DRIVER_ID_ARM_PROPRIETARY_KHR, - eGooglePastel = VK_DRIVER_ID_GOOGLE_PASTEL_KHR + eGooglePastel = VK_DRIVER_ID_GOOGLE_PASTEL_KHR, + eGgpProprietary = VK_DRIVER_ID_GGP_PROPRIETARY_KHR }; VULKAN_HPP_INLINE std::string to_string( DriverIdKHR value ) @@ -3231,6 +3288,7 @@ namespace VULKAN_HPP_NAMESPACE case DriverIdKHR::eQualcommProprietary : return "QualcommProprietary"; case DriverIdKHR::eArmProprietary : return "ArmProprietary"; case DriverIdKHR::eGooglePastel : return "GooglePastel"; + case DriverIdKHR::eGgpProprietary : return "GgpProprietary"; default: return "invalid"; } } @@ -3812,6 +3870,28 @@ namespace VULKAN_HPP_NAMESPACE } } +#ifdef VK_USE_PLATFORM_WIN32_KHR + enum class FullScreenExclusiveEXT + { + eDefault = VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT, + eAllowed = VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT, + eDisallowed = VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT, + eApplicationControlled = VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( FullScreenExclusiveEXT value ) + { + switch ( value ) + { + case FullScreenExclusiveEXT::eDefault : return "Default"; + case FullScreenExclusiveEXT::eAllowed : return "Allowed"; + case FullScreenExclusiveEXT::eDisallowed : return "Disallowed"; + case FullScreenExclusiveEXT::eApplicationControlled : return "ApplicationControlled"; + default: return "invalid"; + } + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + enum class GeometryTypeNV { eTriangles = VK_GEOMETRY_TYPE_TRIANGLES_NV, @@ -4427,6 +4507,7 @@ namespace VULKAN_HPP_NAMESPACE eErrorFragmentationEXT = VK_ERROR_FRAGMENTATION_EXT, eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT, eErrorInvalidDeviceAddressEXT = VK_ERROR_INVALID_DEVICE_ADDRESS_EXT, + eErrorFullScreenExclusiveModeLostEXT = VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT, eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY_KHR, eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR }; @@ -4466,6 +4547,7 @@ namespace VULKAN_HPP_NAMESPACE case Result::eErrorFragmentationEXT : return "ErrorFragmentationEXT"; case Result::eErrorNotPermittedEXT : return "ErrorNotPermittedEXT"; case Result::eErrorInvalidDeviceAddressEXT : return "ErrorInvalidDeviceAddressEXT"; + case Result::eErrorFullScreenExclusiveModeLostEXT : return "ErrorFullScreenExclusiveModeLostEXT"; default: return "invalid"; } } @@ -4834,6 +4916,7 @@ namespace VULKAN_HPP_NAMESPACE ePipelineRasterizationStateStreamCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT, eImageViewHandleInfoNVX = VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX, eTextureLodGatherFormatPropertiesAMD = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD, + eStreamDescriptorSurfaceCreateInfoGGP = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP, ePhysicalDeviceCornerSampledImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, eExternalMemoryImageCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, eExportMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV, @@ -4981,6 +5064,8 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceVertexAttributeDivisorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, ePipelineVertexInputDivisorStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT, ePhysicalDeviceVertexAttributeDivisorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, + ePresentFrameTokenGGP = VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP, + ePipelineCreationFeedbackCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT, ePhysicalDeviceDriverPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR, ePhysicalDeviceFloatControlsPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR, ePhysicalDeviceDepthStencilResolvePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR, @@ -4996,6 +5081,8 @@ namespace VULKAN_HPP_NAMESPACE eQueueFamilyCheckpointPropertiesNV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV, ePhysicalDeviceVulkanMemoryModelFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR, ePhysicalDevicePciBusInfoPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT, + eDisplayNativeHdrSurfaceCapabilitiesAMD = VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD, + eSwapchainDisplayNativeHdrCreateInfoAMD = VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD, eImagepipeSurfaceCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA, eMetalSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT, ePhysicalDeviceFragmentDensityMapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, @@ -5005,6 +5092,7 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceMemoryBudgetPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT, ePhysicalDeviceMemoryPriorityFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, eMemoryPriorityAllocateInfoEXT = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT, + eSurfaceProtectedCapabilitiesKHR = VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR, ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, ePhysicalDeviceBufferAddressFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT, eBufferDeviceAddressInfoEXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT, @@ -5015,6 +5103,10 @@ namespace VULKAN_HPP_NAMESPACE eCooperativeMatrixPropertiesNV = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV, ePhysicalDeviceCooperativeMatrixPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV, ePhysicalDeviceYcbcrImageArraysFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT, + eSurfaceFullScreenExclusiveInfoEXT = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT, + eSurfaceCapabilitiesFullScreenExclusiveEXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT, + eSurfaceFullScreenExclusiveWin32InfoEXT = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT, + ePhysicalDeviceHostQueryResetFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, eDebugReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT, eRenderPassMultiviewCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR, ePhysicalDeviceMultiviewFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR, @@ -5224,6 +5316,7 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePipelineRasterizationStateStreamCreateInfoEXT : return "PipelineRasterizationStateStreamCreateInfoEXT"; case StructureType::eImageViewHandleInfoNVX : return "ImageViewHandleInfoNVX"; case StructureType::eTextureLodGatherFormatPropertiesAMD : return "TextureLodGatherFormatPropertiesAMD"; + case StructureType::eStreamDescriptorSurfaceCreateInfoGGP : return "StreamDescriptorSurfaceCreateInfoGGP"; case StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV : return "PhysicalDeviceCornerSampledImageFeaturesNV"; case StructureType::eExternalMemoryImageCreateInfoNV : return "ExternalMemoryImageCreateInfoNV"; case StructureType::eExportMemoryAllocateInfoNV : return "ExportMemoryAllocateInfoNV"; @@ -5371,6 +5464,8 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT : return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT"; case StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT : return "PipelineVertexInputDivisorStateCreateInfoEXT"; case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT : return "PhysicalDeviceVertexAttributeDivisorFeaturesEXT"; + case StructureType::ePresentFrameTokenGGP : return "PresentFrameTokenGGP"; + case StructureType::ePipelineCreationFeedbackCreateInfoEXT : return "PipelineCreationFeedbackCreateInfoEXT"; case StructureType::ePhysicalDeviceDriverPropertiesKHR : return "PhysicalDeviceDriverPropertiesKHR"; case StructureType::ePhysicalDeviceFloatControlsPropertiesKHR : return "PhysicalDeviceFloatControlsPropertiesKHR"; case StructureType::ePhysicalDeviceDepthStencilResolvePropertiesKHR : return "PhysicalDeviceDepthStencilResolvePropertiesKHR"; @@ -5386,6 +5481,8 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eQueueFamilyCheckpointPropertiesNV : return "QueueFamilyCheckpointPropertiesNV"; case StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR : return "PhysicalDeviceVulkanMemoryModelFeaturesKHR"; case StructureType::ePhysicalDevicePciBusInfoPropertiesEXT : return "PhysicalDevicePciBusInfoPropertiesEXT"; + case StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD : return "DisplayNativeHdrSurfaceCapabilitiesAMD"; + case StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD : return "SwapchainDisplayNativeHdrCreateInfoAMD"; case StructureType::eImagepipeSurfaceCreateInfoFUCHSIA : return "ImagepipeSurfaceCreateInfoFUCHSIA"; case StructureType::eMetalSurfaceCreateInfoEXT : return "MetalSurfaceCreateInfoEXT"; case StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT : return "PhysicalDeviceFragmentDensityMapFeaturesEXT"; @@ -5395,6 +5492,7 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT : return "PhysicalDeviceMemoryBudgetPropertiesEXT"; case StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT : return "PhysicalDeviceMemoryPriorityFeaturesEXT"; case StructureType::eMemoryPriorityAllocateInfoEXT : return "MemoryPriorityAllocateInfoEXT"; + case StructureType::eSurfaceProtectedCapabilitiesKHR : return "SurfaceProtectedCapabilitiesKHR"; case StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV : return "PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV"; case StructureType::ePhysicalDeviceBufferAddressFeaturesEXT : return "PhysicalDeviceBufferAddressFeaturesEXT"; case StructureType::eBufferDeviceAddressInfoEXT : return "BufferDeviceAddressInfoEXT"; @@ -5405,6 +5503,10 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eCooperativeMatrixPropertiesNV : return "CooperativeMatrixPropertiesNV"; case StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV : return "PhysicalDeviceCooperativeMatrixPropertiesNV"; case StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT : return "PhysicalDeviceYcbcrImageArraysFeaturesEXT"; + case StructureType::eSurfaceFullScreenExclusiveInfoEXT : return "SurfaceFullScreenExclusiveInfoEXT"; + case StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT : return "SurfaceCapabilitiesFullScreenExclusiveEXT"; + case StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT : return "SurfaceFullScreenExclusiveWin32InfoEXT"; + case StructureType::ePhysicalDeviceHostQueryResetFeaturesEXT : return "PhysicalDeviceHostQueryResetFeaturesEXT"; default: return "invalid"; } } @@ -8619,6 +8721,55 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + enum class PipelineCreationFeedbackFlagBitsEXT + { + eValid = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT, + eApplicationPipelineCacheHit = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT, + eBasePipelineAcceleration = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineCreationFeedbackFlagBitsEXT value ) + { + switch ( value ) + { + case PipelineCreationFeedbackFlagBitsEXT::eValid : return "Valid"; + case PipelineCreationFeedbackFlagBitsEXT::eApplicationPipelineCacheHit : return "ApplicationPipelineCacheHit"; + case PipelineCreationFeedbackFlagBitsEXT::eBasePipelineAcceleration : return "BasePipelineAcceleration"; + default: return "invalid"; + } + } + + using PipelineCreationFeedbackFlagsEXT = Flags<PipelineCreationFeedbackFlagBitsEXT, VkPipelineCreationFeedbackFlagsEXT>; + + VULKAN_HPP_INLINE PipelineCreationFeedbackFlagsEXT operator|( PipelineCreationFeedbackFlagBitsEXT bit0, PipelineCreationFeedbackFlagBitsEXT bit1 ) + { + return PipelineCreationFeedbackFlagsEXT( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE PipelineCreationFeedbackFlagsEXT operator~( PipelineCreationFeedbackFlagBitsEXT bits ) + { + return ~( PipelineCreationFeedbackFlagsEXT( bits ) ); + } + + template <> struct FlagTraits<PipelineCreationFeedbackFlagBitsEXT> + { + enum + { + allFlags = VkFlags(PipelineCreationFeedbackFlagBitsEXT::eValid) | VkFlags(PipelineCreationFeedbackFlagBitsEXT::eApplicationPipelineCacheHit) | VkFlags(PipelineCreationFeedbackFlagBitsEXT::eBasePipelineAcceleration) + }; + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineCreationFeedbackFlagsEXT value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & PipelineCreationFeedbackFlagBitsEXT::eValid ) result += "Valid | "; + if ( value & PipelineCreationFeedbackFlagBitsEXT::eApplicationPipelineCacheHit ) result += "ApplicationPipelineCacheHit | "; + if ( value & PipelineCreationFeedbackFlagBitsEXT::eBasePipelineAcceleration ) result += "BasePipelineAcceleration | "; + return "{ " + result.substr(0, result.size() - 3) + " }"; + } + enum class PipelineDepthStencilStateCreateFlagBits {}; @@ -9682,6 +9833,23 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } +#ifdef VK_USE_PLATFORM_GGP + enum class StreamDescriptorSurfaceCreateFlagBitsGGP + {}; + + VULKAN_HPP_INLINE std::string to_string( StreamDescriptorSurfaceCreateFlagBitsGGP ) + { + return "(void)"; + } + + using StreamDescriptorSurfaceCreateFlagsGGP = Flags<StreamDescriptorSurfaceCreateFlagBitsGGP, VkStreamDescriptorSurfaceCreateFlagsGGP>; + + VULKAN_HPP_INLINE std::string to_string( StreamDescriptorSurfaceCreateFlagsGGP ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_GGP*/ + enum class SubgroupFeatureFlagBits { eBasic = VK_SUBGROUP_FEATURE_BASIC_BIT, @@ -10352,6 +10520,15 @@ namespace VULKAN_HPP_NAMESPACE : SystemError( make_error_code( Result::eErrorInvalidDeviceAddressEXT ), message ) {} }; + class FullScreenExclusiveModeLostEXTError : public SystemError + { + public: + FullScreenExclusiveModeLostEXTError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {} + FullScreenExclusiveModeLostEXTError( char const * message ) + : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {} + }; + VULKAN_HPP_INLINE void throwResultException( Result result, char const * message ) { @@ -10381,6 +10558,7 @@ namespace VULKAN_HPP_NAMESPACE case Result::eErrorFragmentationEXT: throw FragmentationEXTError( message ); case Result::eErrorNotPermittedEXT: throw NotPermittedEXTError( message ); case Result::eErrorInvalidDeviceAddressEXT: throw InvalidDeviceAddressEXTError( message ); + case Result::eErrorFullScreenExclusiveModeLostEXT: throw FullScreenExclusiveModeLostEXTError( message ); default: throw SystemError( make_error_code( result ) ); } } @@ -10510,19 +10688,41 @@ namespace VULKAN_HPP_NAMESPACE struct AcquireNextImageInfoKHR; struct AllocationCallbacks; #ifdef VK_USE_PLATFORM_ANDROID_KHR + struct AndroidHardwareBufferFormatPropertiesANDROID; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ +#ifdef VK_USE_PLATFORM_ANDROID_KHR struct AndroidHardwareBufferPropertiesANDROID; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ #ifdef VK_USE_PLATFORM_ANDROID_KHR + struct AndroidHardwareBufferUsageANDROID; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ +#ifdef VK_USE_PLATFORM_ANDROID_KHR struct AndroidSurfaceCreateInfoKHR; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + struct ApplicationInfo; + struct AttachmentDescription; + struct AttachmentDescription2KHR; + struct AttachmentReference; + struct AttachmentReference2KHR; + struct AttachmentSampleLocationsEXT; + struct BaseInStructure; + struct BaseOutStructure; struct BindAccelerationStructureMemoryInfoNV; + struct BindBufferMemoryDeviceGroupInfo; + using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo; struct BindBufferMemoryInfo; using BindBufferMemoryInfoKHR = BindBufferMemoryInfo; + struct BindImageMemoryDeviceGroupInfo; + using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo; struct BindImageMemoryInfo; using BindImageMemoryInfoKHR = BindImageMemoryInfo; + struct BindImageMemorySwapchainInfoKHR; + struct BindImagePlaneMemoryInfo; + using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo; struct BindSparseInfo; struct BufferCopy; struct BufferCreateInfo; + struct BufferDeviceAddressCreateInfoEXT; struct BufferDeviceAddressInfoEXT; struct BufferImageCopy; struct BufferMemoryBarrier; @@ -10535,16 +10735,25 @@ namespace VULKAN_HPP_NAMESPACE union ClearColorValue; struct ClearDepthStencilValue; struct ClearRect; + union ClearValue; struct CmdProcessCommandsInfoNVX; struct CmdReserveSpaceForCommandsInfoNVX; + struct CoarseSampleLocationNV; struct CoarseSampleOrderCustomNV; struct CommandBufferAllocateInfo; struct CommandBufferBeginInfo; + struct CommandBufferInheritanceConditionalRenderingInfoEXT; + struct CommandBufferInheritanceInfo; struct CommandPoolCreateInfo; + struct ComponentMapping; struct ComputePipelineCreateInfo; struct ConditionalRenderingBeginInfoEXT; + struct ConformanceVersionKHR; struct CooperativeMatrixPropertiesNV; struct CopyDescriptorSet; +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct D3D12FenceSubmitInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct DebugMarkerMarkerInfoEXT; struct DebugMarkerObjectNameInfoEXT; struct DebugMarkerObjectTagInfoEXT; @@ -10554,40 +10763,109 @@ namespace VULKAN_HPP_NAMESPACE struct DebugUtilsMessengerCreateInfoEXT; struct DebugUtilsObjectNameInfoEXT; struct DebugUtilsObjectTagInfoEXT; + struct DedicatedAllocationBufferCreateInfoNV; + struct DedicatedAllocationImageCreateInfoNV; + struct DedicatedAllocationMemoryAllocateInfoNV; + struct DescriptorBufferInfo; + struct DescriptorImageInfo; struct DescriptorPoolCreateInfo; + struct DescriptorPoolInlineUniformBlockCreateInfoEXT; + struct DescriptorPoolSize; struct DescriptorSetAllocateInfo; + struct DescriptorSetLayoutBinding; + struct DescriptorSetLayoutBindingFlagsCreateInfoEXT; struct DescriptorSetLayoutCreateInfo; struct DescriptorSetLayoutSupport; using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport; + struct DescriptorSetVariableDescriptorCountAllocateInfoEXT; + struct DescriptorSetVariableDescriptorCountLayoutSupportEXT; struct DescriptorUpdateTemplateCreateInfo; using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo; + struct DescriptorUpdateTemplateEntry; + using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry; struct DeviceCreateInfo; struct DeviceEventInfoEXT; struct DeviceGeneratedCommandsFeaturesNVX; struct DeviceGeneratedCommandsLimitsNVX; + struct DeviceGroupBindSparseInfo; + using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo; + struct DeviceGroupCommandBufferBeginInfo; + using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo; + struct DeviceGroupDeviceCreateInfo; + using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo; struct DeviceGroupPresentCapabilitiesKHR; + struct DeviceGroupPresentInfoKHR; + struct DeviceGroupRenderPassBeginInfo; + using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo; + struct DeviceGroupSubmitInfo; + using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo; + struct DeviceGroupSwapchainCreateInfoKHR; + struct DeviceMemoryOverallocationCreateInfoAMD; + struct DeviceQueueCreateInfo; + struct DeviceQueueGlobalPriorityCreateInfoEXT; struct DeviceQueueInfo2; + struct DispatchIndirectCommand; struct DisplayEventInfoEXT; struct DisplayModeCreateInfoKHR; + struct DisplayModeParametersKHR; struct DisplayModeProperties2KHR; struct DisplayModePropertiesKHR; + struct DisplayNativeHdrSurfaceCapabilitiesAMD; struct DisplayPlaneCapabilities2KHR; struct DisplayPlaneCapabilitiesKHR; struct DisplayPlaneInfo2KHR; struct DisplayPlaneProperties2KHR; struct DisplayPlanePropertiesKHR; struct DisplayPowerInfoEXT; + struct DisplayPresentInfoKHR; struct DisplayProperties2KHR; struct DisplayPropertiesKHR; struct DisplaySurfaceCreateInfoKHR; + struct DrawIndexedIndirectCommand; + struct DrawIndirectCommand; + struct DrawMeshTasksIndirectCommandNV; + struct DrmFormatModifierPropertiesEXT; + struct DrmFormatModifierPropertiesListEXT; struct EventCreateInfo; + struct ExportFenceCreateInfo; + using ExportFenceCreateInfoKHR = ExportFenceCreateInfo; +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ExportFenceWin32HandleInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + struct ExportMemoryAllocateInfo; + using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo; + struct ExportMemoryAllocateInfoNV; +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ExportMemoryWin32HandleInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ExportMemoryWin32HandleInfoNV; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + struct ExportSemaphoreCreateInfo; + using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo; +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ExportSemaphoreWin32HandleInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct ExtensionProperties; struct Extent2D; + struct Extent3D; struct ExternalBufferProperties; using ExternalBufferPropertiesKHR = ExternalBufferProperties; struct ExternalFenceProperties; using ExternalFencePropertiesKHR = ExternalFenceProperties; +#ifdef VK_USE_PLATFORM_ANDROID_KHR + struct ExternalFormatANDROID; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + struct ExternalImageFormatProperties; + using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties; struct ExternalImageFormatPropertiesNV; + struct ExternalMemoryBufferCreateInfo; + using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo; + struct ExternalMemoryImageCreateInfo; + using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo; + struct ExternalMemoryImageCreateInfoNV; + struct ExternalMemoryProperties; + using ExternalMemoryPropertiesKHR = ExternalMemoryProperties; struct ExternalSemaphoreProperties; using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties; struct FenceCreateInfo; @@ -10595,10 +10873,15 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR struct FenceGetWin32HandleInfoKHR; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ + struct FilterCubicImageViewImageFormatPropertiesEXT; struct FormatProperties; struct FormatProperties2; using FormatProperties2KHR = FormatProperties2; struct FramebufferCreateInfo; + struct GeometryAABBNV; + struct GeometryDataNV; + struct GeometryNV; + struct GeometryTrianglesNV; struct GraphicsPipelineCreateInfo; struct HdrMetadataEXT; #ifdef VK_USE_PLATFORM_IOS_MVK @@ -10607,7 +10890,10 @@ namespace VULKAN_HPP_NAMESPACE struct ImageBlit; struct ImageCopy; struct ImageCreateInfo; + struct ImageDrmFormatModifierExplicitCreateInfoEXT; + struct ImageDrmFormatModifierListCreateInfoEXT; struct ImageDrmFormatModifierPropertiesEXT; + struct ImageFormatListCreateInfoKHR; struct ImageFormatProperties; struct ImageFormatProperties2; using ImageFormatProperties2KHR = ImageFormatProperties2; @@ -10617,30 +10903,59 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_FUCHSIA struct ImagePipeSurfaceCreateInfoFUCHSIA; #endif /*VK_USE_PLATFORM_FUCHSIA*/ + struct ImagePlaneMemoryRequirementsInfo; + using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo; struct ImageResolve; struct ImageSparseMemoryRequirementsInfo2; using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2; + struct ImageStencilUsageCreateInfoEXT; struct ImageSubresource; + struct ImageSubresourceLayers; struct ImageSubresourceRange; + struct ImageSwapchainCreateInfoKHR; + struct ImageViewASTCDecodeModeEXT; struct ImageViewCreateInfo; struct ImageViewHandleInfoNVX; + struct ImageViewUsageCreateInfo; + using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo; +#ifdef VK_USE_PLATFORM_ANDROID_KHR + struct ImportAndroidHardwareBufferInfoANDROID; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ struct ImportFenceFdInfoKHR; #ifdef VK_USE_PLATFORM_WIN32_KHR struct ImportFenceWin32HandleInfoKHR; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ + struct ImportMemoryFdInfoKHR; + struct ImportMemoryHostPointerInfoEXT; +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ImportMemoryWin32HandleInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ImportMemoryWin32HandleInfoNV; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct ImportSemaphoreFdInfoKHR; #ifdef VK_USE_PLATFORM_WIN32_KHR struct ImportSemaphoreWin32HandleInfoKHR; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct IndirectCommandsLayoutCreateInfoNVX; + struct IndirectCommandsLayoutTokenNVX; + struct IndirectCommandsTokenNVX; + struct InputAttachmentAspectReference; + using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference; struct InstanceCreateInfo; struct LayerProperties; #ifdef VK_USE_PLATFORM_MACOS_MVK struct MacOSSurfaceCreateInfoMVK; #endif /*VK_USE_PLATFORM_MACOS_MVK*/ struct MappedMemoryRange; + struct MemoryAllocateFlagsInfo; + using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo; struct MemoryAllocateInfo; struct MemoryBarrier; + struct MemoryDedicatedAllocateInfo; + using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo; + struct MemoryDedicatedRequirements; + using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements; struct MemoryFdPropertiesKHR; #ifdef VK_USE_PLATFORM_ANDROID_KHR struct MemoryGetAndroidHardwareBufferInfoANDROID; @@ -10649,10 +10964,13 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR struct MemoryGetWin32HandleInfoKHR; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ + struct MemoryHeap; struct MemoryHostPointerPropertiesEXT; + struct MemoryPriorityAllocateInfoEXT; struct MemoryRequirements; struct MemoryRequirements2; using MemoryRequirements2KHR = MemoryRequirements2; + struct MemoryType; #ifdef VK_USE_PLATFORM_WIN32_KHR struct MemoryWin32HandlePropertiesKHR; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -10661,83 +10979,271 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VK_USE_PLATFORM_METAL_EXT*/ struct MultisamplePropertiesEXT; struct ObjectTableCreateInfoNVX; + struct ObjectTableDescriptorSetEntryNVX; struct ObjectTableEntryNVX; + struct ObjectTableIndexBufferEntryNVX; + struct ObjectTablePipelineEntryNVX; + struct ObjectTablePushConstantEntryNVX; + struct ObjectTableVertexBufferEntryNVX; + struct Offset2D; + struct Offset3D; struct PastPresentationTimingGOOGLE; + struct PhysicalDevice16BitStorageFeatures; + using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures; + struct PhysicalDevice8BitStorageFeaturesKHR; + struct PhysicalDeviceASTCDecodeFeaturesEXT; + struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT; + struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT; + struct PhysicalDeviceBufferAddressFeaturesEXT; + struct PhysicalDeviceComputeShaderDerivativesFeaturesNV; + struct PhysicalDeviceConditionalRenderingFeaturesEXT; + struct PhysicalDeviceConservativeRasterizationPropertiesEXT; + struct PhysicalDeviceCooperativeMatrixFeaturesNV; + struct PhysicalDeviceCooperativeMatrixPropertiesNV; + struct PhysicalDeviceCornerSampledImageFeaturesNV; + struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + struct PhysicalDeviceDepthClipEnableFeaturesEXT; + struct PhysicalDeviceDepthStencilResolvePropertiesKHR; + struct PhysicalDeviceDescriptorIndexingFeaturesEXT; + struct PhysicalDeviceDescriptorIndexingPropertiesEXT; + struct PhysicalDeviceDiscardRectanglePropertiesEXT; + struct PhysicalDeviceDriverPropertiesKHR; + struct PhysicalDeviceExclusiveScissorFeaturesNV; struct PhysicalDeviceExternalBufferInfo; using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo; struct PhysicalDeviceExternalFenceInfo; using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo; + struct PhysicalDeviceExternalImageFormatInfo; + using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo; + struct PhysicalDeviceExternalMemoryHostPropertiesEXT; struct PhysicalDeviceExternalSemaphoreInfo; using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo; struct PhysicalDeviceFeatures; struct PhysicalDeviceFeatures2; using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2; + struct PhysicalDeviceFloat16Int8FeaturesKHR; + struct PhysicalDeviceFloatControlsPropertiesKHR; + struct PhysicalDeviceFragmentDensityMapFeaturesEXT; + struct PhysicalDeviceFragmentDensityMapPropertiesEXT; + struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV; struct PhysicalDeviceGroupProperties; using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties; + struct PhysicalDeviceHostQueryResetFeaturesEXT; + struct PhysicalDeviceIDProperties; + using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties; + struct PhysicalDeviceImageDrmFormatModifierInfoEXT; struct PhysicalDeviceImageFormatInfo2; using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2; + struct PhysicalDeviceImageViewImageFormatInfoEXT; + struct PhysicalDeviceInlineUniformBlockFeaturesEXT; + struct PhysicalDeviceInlineUniformBlockPropertiesEXT; + struct PhysicalDeviceLimits; + struct PhysicalDeviceMaintenance3Properties; + using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties; + struct PhysicalDeviceMemoryBudgetPropertiesEXT; + struct PhysicalDeviceMemoryPriorityFeaturesEXT; struct PhysicalDeviceMemoryProperties; struct PhysicalDeviceMemoryProperties2; using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2; + struct PhysicalDeviceMeshShaderFeaturesNV; + struct PhysicalDeviceMeshShaderPropertiesNV; + struct PhysicalDeviceMultiviewFeatures; + using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures; + struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + struct PhysicalDeviceMultiviewProperties; + using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties; + struct PhysicalDevicePCIBusInfoPropertiesEXT; + struct PhysicalDevicePointClippingProperties; + using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties; struct PhysicalDeviceProperties; struct PhysicalDeviceProperties2; using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2; + struct PhysicalDeviceProtectedMemoryFeatures; + struct PhysicalDeviceProtectedMemoryProperties; + struct PhysicalDevicePushDescriptorPropertiesKHR; + struct PhysicalDeviceRayTracingPropertiesNV; + struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV; + struct PhysicalDeviceSampleLocationsPropertiesEXT; + struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT; + struct PhysicalDeviceSamplerYcbcrConversionFeatures; + using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures; + struct PhysicalDeviceScalarBlockLayoutFeaturesEXT; + struct PhysicalDeviceShaderAtomicInt64FeaturesKHR; + struct PhysicalDeviceShaderCorePropertiesAMD; + struct PhysicalDeviceShaderDrawParameterFeatures; + struct PhysicalDeviceShaderImageFootprintFeaturesNV; + struct PhysicalDeviceShadingRateImageFeaturesNV; + struct PhysicalDeviceShadingRateImagePropertiesNV; struct PhysicalDeviceSparseImageFormatInfo2; using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2; + struct PhysicalDeviceSparseProperties; + struct PhysicalDeviceSubgroupProperties; struct PhysicalDeviceSurfaceInfo2KHR; + struct PhysicalDeviceTransformFeedbackFeaturesEXT; + struct PhysicalDeviceTransformFeedbackPropertiesEXT; + struct PhysicalDeviceVariablePointerFeatures; + using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointerFeatures; + struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT; + struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT; + struct PhysicalDeviceVulkanMemoryModelFeaturesKHR; + struct PhysicalDeviceYcbcrImageArraysFeaturesEXT; struct PipelineCacheCreateInfo; + struct PipelineColorBlendAdvancedStateCreateInfoEXT; + struct PipelineColorBlendAttachmentState; + struct PipelineColorBlendStateCreateInfo; + struct PipelineCoverageModulationStateCreateInfoNV; + struct PipelineCoverageToColorStateCreateInfoNV; + struct PipelineCreationFeedbackCreateInfoEXT; + struct PipelineCreationFeedbackEXT; + struct PipelineDepthStencilStateCreateInfo; + struct PipelineDiscardRectangleStateCreateInfoEXT; + struct PipelineDynamicStateCreateInfo; + struct PipelineInputAssemblyStateCreateInfo; struct PipelineLayoutCreateInfo; + struct PipelineMultisampleStateCreateInfo; + struct PipelineRasterizationConservativeStateCreateInfoEXT; + struct PipelineRasterizationDepthClipStateCreateInfoEXT; + struct PipelineRasterizationStateCreateInfo; + struct PipelineRasterizationStateRasterizationOrderAMD; + struct PipelineRasterizationStateStreamCreateInfoEXT; + struct PipelineRepresentativeFragmentTestStateCreateInfoNV; + struct PipelineSampleLocationsStateCreateInfoEXT; + struct PipelineShaderStageCreateInfo; + struct PipelineTessellationDomainOriginStateCreateInfo; + using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo; + struct PipelineTessellationStateCreateInfo; + struct PipelineVertexInputDivisorStateCreateInfoEXT; + struct PipelineVertexInputStateCreateInfo; + struct PipelineViewportCoarseSampleOrderStateCreateInfoNV; + struct PipelineViewportExclusiveScissorStateCreateInfoNV; + struct PipelineViewportShadingRateImageStateCreateInfoNV; + struct PipelineViewportStateCreateInfo; + struct PipelineViewportSwizzleStateCreateInfoNV; + struct PipelineViewportWScalingStateCreateInfoNV; +#ifdef VK_USE_PLATFORM_GGP + struct PresentFrameTokenGGP; +#endif /*VK_USE_PLATFORM_GGP*/ struct PresentInfoKHR; + struct PresentRegionKHR; + struct PresentRegionsKHR; + struct PresentTimeGOOGLE; + struct PresentTimesInfoGOOGLE; + struct ProtectedSubmitInfo; + struct PushConstantRange; struct QueryPoolCreateInfo; + struct QueueFamilyCheckpointPropertiesNV; struct QueueFamilyProperties; struct QueueFamilyProperties2; using QueueFamilyProperties2KHR = QueueFamilyProperties2; struct RayTracingPipelineCreateInfoNV; + struct RayTracingShaderGroupCreateInfoNV; struct Rect2D; + struct RectLayerKHR; struct RefreshCycleDurationGOOGLE; struct RenderPassBeginInfo; struct RenderPassCreateInfo; struct RenderPassCreateInfo2KHR; + struct RenderPassFragmentDensityMapCreateInfoEXT; + struct RenderPassInputAttachmentAspectCreateInfo; + using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo; + struct RenderPassMultiviewCreateInfo; + using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo; + struct RenderPassSampleLocationsBeginInfoEXT; + struct SampleLocationEXT; struct SampleLocationsInfoEXT; struct SamplerCreateInfo; + struct SamplerReductionModeCreateInfoEXT; struct SamplerYcbcrConversionCreateInfo; using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo; + struct SamplerYcbcrConversionImageFormatProperties; + using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties; + struct SamplerYcbcrConversionInfo; + using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo; struct SemaphoreCreateInfo; struct SemaphoreGetFdInfoKHR; #ifdef VK_USE_PLATFORM_WIN32_KHR struct SemaphoreGetWin32HandleInfoKHR; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct ShaderModuleCreateInfo; + struct ShaderModuleValidationCacheCreateInfoEXT; + struct ShaderResourceUsageAMD; + struct ShaderStatisticsInfoAMD; struct ShadingRatePaletteNV; + struct SharedPresentSurfaceCapabilitiesKHR; + struct SparseBufferMemoryBindInfo; struct SparseImageFormatProperties; struct SparseImageFormatProperties2; using SparseImageFormatProperties2KHR = SparseImageFormatProperties2; + struct SparseImageMemoryBind; + struct SparseImageMemoryBindInfo; struct SparseImageMemoryRequirements; struct SparseImageMemoryRequirements2; using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2; + struct SparseImageOpaqueMemoryBindInfo; + struct SparseMemoryBind; + struct SpecializationInfo; + struct SpecializationMapEntry; + struct StencilOpState; +#ifdef VK_USE_PLATFORM_GGP + struct StreamDescriptorSurfaceCreateInfoGGP; +#endif /*VK_USE_PLATFORM_GGP*/ struct SubmitInfo; struct SubpassBeginInfoKHR; + struct SubpassDependency; + struct SubpassDependency2KHR; + struct SubpassDescription; + struct SubpassDescription2KHR; + struct SubpassDescriptionDepthStencilResolveKHR; struct SubpassEndInfoKHR; + struct SubpassSampleLocationsEXT; struct SubresourceLayout; struct SurfaceCapabilities2EXT; struct SurfaceCapabilities2KHR; +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct SurfaceCapabilitiesFullScreenExclusiveEXT; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct SurfaceCapabilitiesKHR; struct SurfaceFormat2KHR; struct SurfaceFormatKHR; +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct SurfaceFullScreenExclusiveInfoEXT; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct SurfaceFullScreenExclusiveWin32InfoEXT; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + struct SurfaceProtectedCapabilitiesKHR; + struct SwapchainCounterCreateInfoEXT; struct SwapchainCreateInfoKHR; + struct SwapchainDisplayNativeHdrCreateInfoAMD; + struct TextureLODGatherFormatPropertiesAMD; struct ValidationCacheCreateInfoEXT; + struct ValidationFeaturesEXT; + struct ValidationFlagsEXT; + struct VertexInputAttributeDescription; + struct VertexInputBindingDescription; + struct VertexInputBindingDivisorDescriptionEXT; #ifdef VK_USE_PLATFORM_VI_NN struct ViSurfaceCreateInfoNN; #endif /*VK_USE_PLATFORM_VI_NN*/ struct Viewport; + struct ViewportSwizzleNV; struct ViewportWScalingNV; #ifdef VK_USE_PLATFORM_WAYLAND_KHR struct WaylandSurfaceCreateInfoKHR; #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ #ifdef VK_USE_PLATFORM_WIN32_KHR + struct Win32KeyedMutexAcquireReleaseInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct Win32KeyedMutexAcquireReleaseInfoNV; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR struct Win32SurfaceCreateInfoKHR; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct WriteDescriptorSet; + struct WriteDescriptorSetAccelerationStructureNV; + struct WriteDescriptorSetInlineUniformBlockEXT; + struct XYColorEXT; #ifdef VK_USE_PLATFORM_XCB_KHR struct XcbSurfaceCreateInfoKHR; #endif /*VK_USE_PLATFORM_XCB_KHR*/ @@ -11045,6 +11551,9 @@ namespace VULKAN_HPP_NAMESPACE return m_swapchainKHR < rhs.m_swapchainKHR; } + template<typename Dispatch = DispatchLoaderStatic> + void setLocalDimmingAMD( Bool32 localDimmingEnable, Dispatch const &d = Dispatch() ) const; + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const { return m_swapchainKHR; @@ -13472,6 +13981,16 @@ namespace VULKAN_HPP_NAMESPACE return m_device < rhs.m_device; } +#ifdef VK_USE_PLATFORM_WIN32_KHR +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template<typename Dispatch = DispatchLoaderStatic> + Result acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const; +#else + template<typename Dispatch = DispatchLoaderStatic> + ResultValueType<void>::type acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template<typename Dispatch = DispatchLoaderStatic> Result acquireNextImage2KHR( const AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -14513,6 +15032,15 @@ namespace VULKAN_HPP_NAMESPACE ResultValueType<DeviceGroupPresentCapabilitiesKHR>::type getGroupPresentCapabilitiesKHR(Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template<typename Dispatch = DispatchLoaderStatic> + Result getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template<typename Dispatch = DispatchLoaderStatic> + ResultValueType<DeviceGroupPresentModeFlagsKHR>::type getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template<typename Dispatch = DispatchLoaderStatic> Result getGroupSurfacePresentModesKHR( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -14880,6 +15408,16 @@ namespace VULKAN_HPP_NAMESPACE ResultValueType<void>::type registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectTableEntryNVX* const> pObjectTableEntries, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template<typename Dispatch = DispatchLoaderStatic> + Result releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const; +#else + template<typename Dispatch = DispatchLoaderStatic> + ResultValueType<void>::type releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template<typename Dispatch = DispatchLoaderStatic> Result resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d = Dispatch() ) const; @@ -14912,6 +15450,9 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template<typename Dispatch = DispatchLoaderStatic> + void resetQueryPoolEXT( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d = Dispatch() ) const; + + template<typename Dispatch = DispatchLoaderStatic> Result setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template<typename Dispatch = DispatchLoaderStatic> @@ -15549,6 +16090,17 @@ namespace VULKAN_HPP_NAMESPACE typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template<typename Dispatch = DispatchLoaderStatic> + Result getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template<typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const; + template<typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = DispatchLoaderStatic> + typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Allocator const& vectorAllocator, Dispatch const &d ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template<typename Dispatch = DispatchLoaderStatic> Result getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -15786,6 +16338,19 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_METAL_EXT*/ +#ifdef VK_USE_PLATFORM_GGP + template<typename Dispatch = DispatchLoaderStatic> + Result createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template<typename Dispatch = DispatchLoaderStatic> + ResultValueType<SurfaceKHR>::type createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template<typename Dispatch = DispatchLoaderStatic> + typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_GGP*/ + #ifdef VK_USE_PLATFORM_VI_NN template<typename Dispatch = DispatchLoaderStatic> Result createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const; @@ -19557,7 +20122,7 @@ namespace VULKAN_HPP_NAMESPACE struct BufferDeviceAddressCreateInfoEXT { - BufferDeviceAddressCreateInfoEXT( DeviceSize deviceAddress_ = 0 ) + BufferDeviceAddressCreateInfoEXT( DeviceAddress deviceAddress_ = 0 ) : deviceAddress( deviceAddress_ ) {} @@ -19578,7 +20143,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - BufferDeviceAddressCreateInfoEXT & setDeviceAddress( DeviceSize deviceAddress_ ) + BufferDeviceAddressCreateInfoEXT & setDeviceAddress( DeviceAddress deviceAddress_ ) { deviceAddress = deviceAddress_; return *this; @@ -19611,7 +20176,7 @@ namespace VULKAN_HPP_NAMESPACE public: const void* pNext = nullptr; - DeviceSize deviceAddress; + DeviceAddress deviceAddress; }; static_assert( sizeof( BufferDeviceAddressCreateInfoEXT ) == sizeof( VkBufferDeviceAddressCreateInfoEXT ), "struct and wrapper have different size!" ); @@ -26320,6 +26885,39 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), "struct and wrapper have different size!" ); + struct DisplayNativeHdrSurfaceCapabilitiesAMD + { + operator VkDisplayNativeHdrSurfaceCapabilitiesAMD const&() const + { + return *reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>( this ); + } + + operator VkDisplayNativeHdrSurfaceCapabilitiesAMD &() + { + return *reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>( this ); + } + + bool operator==( DisplayNativeHdrSurfaceCapabilitiesAMD const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( localDimmingSupport == rhs.localDimmingSupport ); + } + + bool operator!=( DisplayNativeHdrSurfaceCapabilitiesAMD const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD; + + public: + void* pNext = nullptr; + Bool32 localDimmingSupport; + }; + static_assert( sizeof( DisplayNativeHdrSurfaceCapabilitiesAMD ) == sizeof( VkDisplayNativeHdrSurfaceCapabilitiesAMD ), "struct and wrapper have different size!" ); + struct DisplayPlaneCapabilitiesKHR { operator VkDisplayPlaneCapabilitiesKHR const&() const @@ -37114,6 +37712,66 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), "struct and wrapper have different size!" ); + struct PhysicalDeviceHostQueryResetFeaturesEXT + { + PhysicalDeviceHostQueryResetFeaturesEXT( Bool32 hostQueryReset_ = 0 ) + : hostQueryReset( hostQueryReset_ ) + {} + + PhysicalDeviceHostQueryResetFeaturesEXT( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceHostQueryResetFeaturesEXT ) ); + } + + PhysicalDeviceHostQueryResetFeaturesEXT& operator=( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceHostQueryResetFeaturesEXT ) ); + return *this; + } + + PhysicalDeviceHostQueryResetFeaturesEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceHostQueryResetFeaturesEXT & setHostQueryReset( Bool32 hostQueryReset_ ) + { + hostQueryReset = hostQueryReset_; + return *this; + } + + operator VkPhysicalDeviceHostQueryResetFeaturesEXT const&() const + { + return *reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeaturesEXT*>( this ); + } + + operator VkPhysicalDeviceHostQueryResetFeaturesEXT &() + { + return *reinterpret_cast<VkPhysicalDeviceHostQueryResetFeaturesEXT*>( this ); + } + + bool operator==( PhysicalDeviceHostQueryResetFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( hostQueryReset == rhs.hostQueryReset ); + } + + bool operator!=( PhysicalDeviceHostQueryResetFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePhysicalDeviceHostQueryResetFeaturesEXT; + + public: + void* pNext = nullptr; + Bool32 hostQueryReset; + }; + static_assert( sizeof( PhysicalDeviceHostQueryResetFeaturesEXT ) == sizeof( VkPhysicalDeviceHostQueryResetFeaturesEXT ), "struct and wrapper have different size!" ); + struct PhysicalDeviceIDProperties { operator VkPhysicalDeviceIDProperties const&() const @@ -40161,6 +40819,114 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "struct and wrapper have different size!" ); + struct PipelineCreationFeedbackEXT + { + operator VkPipelineCreationFeedbackEXT const&() const + { + return *reinterpret_cast<const VkPipelineCreationFeedbackEXT*>( this ); + } + + operator VkPipelineCreationFeedbackEXT &() + { + return *reinterpret_cast<VkPipelineCreationFeedbackEXT*>( this ); + } + + bool operator==( PipelineCreationFeedbackEXT const& rhs ) const + { + return ( flags == rhs.flags ) + && ( duration == rhs.duration ); + } + + bool operator!=( PipelineCreationFeedbackEXT const& rhs ) const + { + return !operator==( rhs ); + } + + PipelineCreationFeedbackFlagsEXT flags; + uint64_t duration; + }; + static_assert( sizeof( PipelineCreationFeedbackEXT ) == sizeof( VkPipelineCreationFeedbackEXT ), "struct and wrapper have different size!" ); + + struct PipelineCreationFeedbackCreateInfoEXT + { + PipelineCreationFeedbackCreateInfoEXT( PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ = nullptr, + uint32_t pipelineStageCreationFeedbackCount_ = 0, + PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ = nullptr ) + : pPipelineCreationFeedback( pPipelineCreationFeedback_ ) + , pipelineStageCreationFeedbackCount( pipelineStageCreationFeedbackCount_ ) + , pPipelineStageCreationFeedbacks( pPipelineStageCreationFeedbacks_ ) + {} + + PipelineCreationFeedbackCreateInfoEXT( VkPipelineCreationFeedbackCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineCreationFeedbackCreateInfoEXT ) ); + } + + PipelineCreationFeedbackCreateInfoEXT& operator=( VkPipelineCreationFeedbackCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineCreationFeedbackCreateInfoEXT ) ); + return *this; + } + + PipelineCreationFeedbackCreateInfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineCreationFeedbackCreateInfoEXT & setPPipelineCreationFeedback( PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ ) + { + pPipelineCreationFeedback = pPipelineCreationFeedback_; + return *this; + } + + PipelineCreationFeedbackCreateInfoEXT & setPipelineStageCreationFeedbackCount( uint32_t pipelineStageCreationFeedbackCount_ ) + { + pipelineStageCreationFeedbackCount = pipelineStageCreationFeedbackCount_; + return *this; + } + + PipelineCreationFeedbackCreateInfoEXT & setPPipelineStageCreationFeedbacks( PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ ) + { + pPipelineStageCreationFeedbacks = pPipelineStageCreationFeedbacks_; + return *this; + } + + operator VkPipelineCreationFeedbackCreateInfoEXT const&() const + { + return *reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>( this ); + } + + operator VkPipelineCreationFeedbackCreateInfoEXT &() + { + return *reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>( this ); + } + + bool operator==( PipelineCreationFeedbackCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( pPipelineCreationFeedback == rhs.pPipelineCreationFeedback ) + && ( pipelineStageCreationFeedbackCount == rhs.pipelineStageCreationFeedbackCount ) + && ( pPipelineStageCreationFeedbacks == rhs.pPipelineStageCreationFeedbacks ); + } + + bool operator!=( PipelineCreationFeedbackCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePipelineCreationFeedbackCreateInfoEXT; + + public: + const void* pNext = nullptr; + PipelineCreationFeedbackEXT* pPipelineCreationFeedback; + uint32_t pipelineStageCreationFeedbackCount; + PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks; + }; + static_assert( sizeof( PipelineCreationFeedbackCreateInfoEXT ) == sizeof( VkPipelineCreationFeedbackCreateInfoEXT ), "struct and wrapper have different size!" ); + struct PipelineDiscardRectangleStateCreateInfoEXT { PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_ = PipelineDiscardRectangleStateCreateFlagsEXT(), @@ -41596,6 +42362,68 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "struct and wrapper have different size!" ); +#ifdef VK_USE_PLATFORM_GGP + struct PresentFrameTokenGGP + { + PresentFrameTokenGGP( GgpFrameToken frameToken_ = 0 ) + : frameToken( frameToken_ ) + {} + + PresentFrameTokenGGP( VkPresentFrameTokenGGP const & rhs ) + { + memcpy( this, &rhs, sizeof( PresentFrameTokenGGP ) ); + } + + PresentFrameTokenGGP& operator=( VkPresentFrameTokenGGP const & rhs ) + { + memcpy( this, &rhs, sizeof( PresentFrameTokenGGP ) ); + return *this; + } + + PresentFrameTokenGGP & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PresentFrameTokenGGP & setFrameToken( GgpFrameToken frameToken_ ) + { + frameToken = frameToken_; + return *this; + } + + operator VkPresentFrameTokenGGP const&() const + { + return *reinterpret_cast<const VkPresentFrameTokenGGP*>( this ); + } + + operator VkPresentFrameTokenGGP &() + { + return *reinterpret_cast<VkPresentFrameTokenGGP*>( this ); + } + + bool operator==( PresentFrameTokenGGP const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( frameToken == rhs.frameToken ); + } + + bool operator!=( PresentFrameTokenGGP const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::ePresentFrameTokenGGP; + + public: + const void* pNext = nullptr; + GgpFrameToken frameToken; + }; + static_assert( sizeof( PresentFrameTokenGGP ) == sizeof( VkPresentFrameTokenGGP ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_GGP*/ + struct PresentInfoKHR { PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0, @@ -44899,6 +45727,78 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "struct and wrapper have different size!" ); +#ifdef VK_USE_PLATFORM_GGP + struct StreamDescriptorSurfaceCreateInfoGGP + { + StreamDescriptorSurfaceCreateInfoGGP( StreamDescriptorSurfaceCreateFlagsGGP flags_ = StreamDescriptorSurfaceCreateFlagsGGP(), + GgpStreamDescriptor streamDescriptor_ = 0 ) + : flags( flags_ ) + , streamDescriptor( streamDescriptor_ ) + {} + + StreamDescriptorSurfaceCreateInfoGGP( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) + { + memcpy( this, &rhs, sizeof( StreamDescriptorSurfaceCreateInfoGGP ) ); + } + + StreamDescriptorSurfaceCreateInfoGGP& operator=( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) + { + memcpy( this, &rhs, sizeof( StreamDescriptorSurfaceCreateInfoGGP ) ); + return *this; + } + + StreamDescriptorSurfaceCreateInfoGGP & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + StreamDescriptorSurfaceCreateInfoGGP & setFlags( StreamDescriptorSurfaceCreateFlagsGGP flags_ ) + { + flags = flags_; + return *this; + } + + StreamDescriptorSurfaceCreateInfoGGP & setStreamDescriptor( GgpStreamDescriptor streamDescriptor_ ) + { + streamDescriptor = streamDescriptor_; + return *this; + } + + operator VkStreamDescriptorSurfaceCreateInfoGGP const&() const + { + return *reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP*>( this ); + } + + operator VkStreamDescriptorSurfaceCreateInfoGGP &() + { + return *reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP*>( this ); + } + + bool operator==( StreamDescriptorSurfaceCreateInfoGGP const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( streamDescriptor == rhs.streamDescriptor ); + } + + bool operator!=( StreamDescriptorSurfaceCreateInfoGGP const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP; + + public: + const void* pNext = nullptr; + StreamDescriptorSurfaceCreateFlagsGGP flags; + GgpStreamDescriptor streamDescriptor; + }; + static_assert( sizeof( StreamDescriptorSurfaceCreateInfoGGP ) == sizeof( VkStreamDescriptorSurfaceCreateInfoGGP ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_GGP*/ + struct SubmitInfo { SubmitInfo( uint32_t waitSemaphoreCount_ = 0, @@ -45340,6 +46240,68 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" ); +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct SurfaceCapabilitiesFullScreenExclusiveEXT + { + SurfaceCapabilitiesFullScreenExclusiveEXT( Bool32 fullScreenExclusiveSupported_ = 0 ) + : fullScreenExclusiveSupported( fullScreenExclusiveSupported_ ) + {} + + SurfaceCapabilitiesFullScreenExclusiveEXT( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) ); + } + + SurfaceCapabilitiesFullScreenExclusiveEXT& operator=( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) ); + return *this; + } + + SurfaceCapabilitiesFullScreenExclusiveEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SurfaceCapabilitiesFullScreenExclusiveEXT & setFullScreenExclusiveSupported( Bool32 fullScreenExclusiveSupported_ ) + { + fullScreenExclusiveSupported = fullScreenExclusiveSupported_; + return *this; + } + + operator VkSurfaceCapabilitiesFullScreenExclusiveEXT const&() const + { + return *reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>( this ); + } + + operator VkSurfaceCapabilitiesFullScreenExclusiveEXT &() + { + return *reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>( this ); + } + + bool operator==( SurfaceCapabilitiesFullScreenExclusiveEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( fullScreenExclusiveSupported == rhs.fullScreenExclusiveSupported ); + } + + bool operator!=( SurfaceCapabilitiesFullScreenExclusiveEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT; + + public: + void* pNext = nullptr; + Bool32 fullScreenExclusiveSupported; + }; + static_assert( sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) == sizeof( VkSurfaceCapabilitiesFullScreenExclusiveEXT ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + struct SurfaceFormatKHR { operator VkSurfaceFormatKHR const&() const @@ -45401,6 +46363,190 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" ); +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct SurfaceFullScreenExclusiveInfoEXT + { + SurfaceFullScreenExclusiveInfoEXT( FullScreenExclusiveEXT fullScreenExclusive_ = FullScreenExclusiveEXT::eDefault ) + : fullScreenExclusive( fullScreenExclusive_ ) + {} + + SurfaceFullScreenExclusiveInfoEXT( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SurfaceFullScreenExclusiveInfoEXT ) ); + } + + SurfaceFullScreenExclusiveInfoEXT& operator=( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SurfaceFullScreenExclusiveInfoEXT ) ); + return *this; + } + + SurfaceFullScreenExclusiveInfoEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SurfaceFullScreenExclusiveInfoEXT & setFullScreenExclusive( FullScreenExclusiveEXT fullScreenExclusive_ ) + { + fullScreenExclusive = fullScreenExclusive_; + return *this; + } + + operator VkSurfaceFullScreenExclusiveInfoEXT const&() const + { + return *reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>( this ); + } + + operator VkSurfaceFullScreenExclusiveInfoEXT &() + { + return *reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>( this ); + } + + bool operator==( SurfaceFullScreenExclusiveInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( fullScreenExclusive == rhs.fullScreenExclusive ); + } + + bool operator!=( SurfaceFullScreenExclusiveInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSurfaceFullScreenExclusiveInfoEXT; + + public: + void* pNext = nullptr; + FullScreenExclusiveEXT fullScreenExclusive; + }; + static_assert( sizeof( SurfaceFullScreenExclusiveInfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveInfoEXT ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct SurfaceFullScreenExclusiveWin32InfoEXT + { + SurfaceFullScreenExclusiveWin32InfoEXT( HMONITOR hmonitor_ = 0 ) + : hmonitor( hmonitor_ ) + {} + + SurfaceFullScreenExclusiveWin32InfoEXT( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) ); + } + + SurfaceFullScreenExclusiveWin32InfoEXT& operator=( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) ); + return *this; + } + + SurfaceFullScreenExclusiveWin32InfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SurfaceFullScreenExclusiveWin32InfoEXT & setHmonitor( HMONITOR hmonitor_ ) + { + hmonitor = hmonitor_; + return *this; + } + + operator VkSurfaceFullScreenExclusiveWin32InfoEXT const&() const + { + return *reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>( this ); + } + + operator VkSurfaceFullScreenExclusiveWin32InfoEXT &() + { + return *reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>( this ); + } + + bool operator==( SurfaceFullScreenExclusiveWin32InfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( hmonitor == rhs.hmonitor ); + } + + bool operator!=( SurfaceFullScreenExclusiveWin32InfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT; + + public: + const void* pNext = nullptr; + HMONITOR hmonitor; + }; + static_assert( sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveWin32InfoEXT ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + struct SurfaceProtectedCapabilitiesKHR + { + SurfaceProtectedCapabilitiesKHR( Bool32 supportsProtected_ = 0 ) + : supportsProtected( supportsProtected_ ) + {} + + SurfaceProtectedCapabilitiesKHR( VkSurfaceProtectedCapabilitiesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SurfaceProtectedCapabilitiesKHR ) ); + } + + SurfaceProtectedCapabilitiesKHR& operator=( VkSurfaceProtectedCapabilitiesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( SurfaceProtectedCapabilitiesKHR ) ); + return *this; + } + + SurfaceProtectedCapabilitiesKHR & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SurfaceProtectedCapabilitiesKHR & setSupportsProtected( Bool32 supportsProtected_ ) + { + supportsProtected = supportsProtected_; + return *this; + } + + operator VkSurfaceProtectedCapabilitiesKHR const&() const + { + return *reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>( this ); + } + + operator VkSurfaceProtectedCapabilitiesKHR &() + { + return *reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>( this ); + } + + bool operator==( SurfaceProtectedCapabilitiesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( supportsProtected == rhs.supportsProtected ); + } + + bool operator!=( SurfaceProtectedCapabilitiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSurfaceProtectedCapabilitiesKHR; + + public: + const void* pNext = nullptr; + Bool32 supportsProtected; + }; + static_assert( sizeof( SurfaceProtectedCapabilitiesKHR ) == sizeof( VkSurfaceProtectedCapabilitiesKHR ), "struct and wrapper have different size!" ); + struct SwapchainCounterCreateInfoEXT { SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = SurfaceCounterFlagsEXT() ) @@ -45671,6 +46817,66 @@ namespace VULKAN_HPP_NAMESPACE }; static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" ); + struct SwapchainDisplayNativeHdrCreateInfoAMD + { + SwapchainDisplayNativeHdrCreateInfoAMD( Bool32 localDimmingEnable_ = 0 ) + : localDimmingEnable( localDimmingEnable_ ) + {} + + SwapchainDisplayNativeHdrCreateInfoAMD( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) + { + memcpy( this, &rhs, sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) ); + } + + SwapchainDisplayNativeHdrCreateInfoAMD& operator=( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) + { + memcpy( this, &rhs, sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) ); + return *this; + } + + SwapchainDisplayNativeHdrCreateInfoAMD & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SwapchainDisplayNativeHdrCreateInfoAMD & setLocalDimmingEnable( Bool32 localDimmingEnable_ ) + { + localDimmingEnable = localDimmingEnable_; + return *this; + } + + operator VkSwapchainDisplayNativeHdrCreateInfoAMD const&() const + { + return *reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>( this ); + } + + operator VkSwapchainDisplayNativeHdrCreateInfoAMD &() + { + return *reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>( this ); + } + + bool operator==( SwapchainDisplayNativeHdrCreateInfoAMD const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( localDimmingEnable == rhs.localDimmingEnable ); + } + + bool operator!=( SwapchainDisplayNativeHdrCreateInfoAMD const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD; + + public: + const void* pNext = nullptr; + Bool32 localDimmingEnable; + }; + static_assert( sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) == sizeof( VkSwapchainDisplayNativeHdrCreateInfoAMD ), "struct and wrapper have different size!" ); + struct TextureLODGatherFormatPropertiesAMD { operator VkTextureLODGatherFormatPropertiesAMD const&() const @@ -48300,6 +49506,23 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template<typename Dispatch> + VULKAN_HPP_INLINE Result Device::acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d) const + { + return static_cast<Result>( d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) ); + } +#else + template<typename Dispatch> + VULKAN_HPP_INLINE ResultValueType<void>::type Device::acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d ) const + { + Result result = static_cast<Result>( d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::acquireFullScreenExclusiveModeEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template<typename Dispatch> VULKAN_HPP_INLINE Result Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d) const { @@ -50675,6 +51898,23 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template<typename Dispatch> + VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d) const + { + return static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModes2EXT( m_device, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>( pModes ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template<typename Dispatch> + VULKAN_HPP_INLINE ResultValueType<DeviceGroupPresentModeFlagsKHR>::type Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const + { + DeviceGroupPresentModeFlagsKHR modes; + Result result = static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModes2EXT( m_device, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>( &modes ) ) ); + return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING"::Device::getGroupSurfacePresentModes2EXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template<typename Dispatch> VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d) const { @@ -51660,6 +52900,23 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template<typename Dispatch> + VULKAN_HPP_INLINE Result Device::releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d) const + { + return static_cast<Result>( d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) ); + } +#else + template<typename Dispatch> + VULKAN_HPP_INLINE ResultValueType<void>::type Device::releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d ) const + { + Result result = static_cast<Result>( d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::releaseFullScreenExclusiveModeEXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template<typename Dispatch> VULKAN_HPP_INLINE Result Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d) const @@ -51719,6 +52976,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template<typename Dispatch> + VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d) const + { + d.vkResetQueryPoolEXT( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount ); + } +#else + template<typename Dispatch> + VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d ) const + { + d.vkResetQueryPoolEXT( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template<typename Dispatch> VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d) const { @@ -52120,6 +53391,34 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_METAL_EXT*/ +#ifdef VK_USE_PLATFORM_GGP + template<typename Dispatch> + VULKAN_HPP_INLINE Result Instance::createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const + { + return static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP( m_instance, reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template<typename Dispatch> + VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP( m_instance, reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); + return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createStreamDescriptorSurfaceGGP" ); + } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template<typename Dispatch> + VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const + { + SurfaceKHR surface; + Result result = static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP( m_instance, reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); + + ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d ); + return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createStreamDescriptorSurfaceGGPUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_GGP*/ + #ifdef VK_USE_PLATFORM_VI_NN template<typename Dispatch> VULKAN_HPP_INLINE Result Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const @@ -54071,6 +55370,60 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template<typename Dispatch> + VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d) const + { + return static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), pPresentModeCount, reinterpret_cast<VkPresentModeKHR*>( pPresentModes ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template<typename Allocator, typename Dispatch> + VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const + { + std::vector<PresentModeKHR,Allocator> presentModes; + uint32_t presentModeCount; + Result result; + do + { + result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &presentModeCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && presentModeCount ) + { + presentModes.resize( presentModeCount ); + result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &presentModeCount, reinterpret_cast<VkPresentModeKHR*>( presentModes.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); + presentModes.resize( presentModeCount ); + } + return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfacePresentModes2EXT" ); + } + template<typename Allocator, typename Dispatch> + VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector<PresentModeKHR,Allocator> presentModes( vectorAllocator ); + uint32_t presentModeCount; + Result result; + do + { + result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &presentModeCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && presentModeCount ) + { + presentModes.resize( presentModeCount ); + result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &presentModeCount, reinterpret_cast<VkPresentModeKHR*>( presentModes.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); + presentModes.resize( presentModeCount ); + } + return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfacePresentModes2EXT" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template<typename Dispatch> VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d) const { @@ -54356,6 +55709,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template<typename Dispatch> + VULKAN_HPP_INLINE void SwapchainKHR::setLocalDimmingAMD( Bool32 localDimmingEnable, Dispatch const &d) const + { + d.vkSetLocalDimmingAMD( m_swapchainKHR, static_cast<VkBool32>( localDimmingEnable ) ); + } +#else + template<typename Dispatch> + VULKAN_HPP_INLINE void SwapchainKHR::setLocalDimmingAMD( Bool32 localDimmingEnable, Dispatch const &d ) const + { + d.vkSetLocalDimmingAMD( m_swapchainKHR, static_cast<VkBool32>( localDimmingEnable ) ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + #ifdef VK_USE_PLATFORM_ANDROID_KHR template <> struct isStructureChainValid<AndroidHardwareBufferPropertiesANDROID, AndroidHardwareBufferFormatPropertiesANDROID>{ enum { value = true }; }; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ @@ -54389,6 +55756,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid<SwapchainCreateInfoKHR, DeviceGroupSwapchainCreateInfoKHR>{ enum { value = true }; }; template <> struct isStructureChainValid<DeviceCreateInfo, DeviceMemoryOverallocationCreateInfoAMD>{ enum { value = true }; }; template <> struct isStructureChainValid<DeviceQueueCreateInfo, DeviceQueueGlobalPriorityCreateInfoEXT>{ enum { value = true }; }; + template <> struct isStructureChainValid<SurfaceCapabilities2KHR, DisplayNativeHdrSurfaceCapabilitiesAMD>{ enum { value = true }; }; template <> struct isStructureChainValid<PresentInfoKHR, DisplayPresentInfoKHR>{ enum { value = true }; }; template <> struct isStructureChainValid<FormatProperties2, DrmFormatModifierPropertiesListEXT>{ enum { value = true }; }; template <> struct isStructureChainValid<FenceCreateInfo, ExportFenceCreateInfo>{ enum { value = true }; }; @@ -54486,6 +55854,8 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceFragmentDensityMapPropertiesEXT>{ enum { value = true }; }; template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceFragmentShaderBarycentricFeaturesNV>{ enum { value = true }; }; template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceFragmentShaderBarycentricFeaturesNV>{ enum { value = true }; }; + template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceHostQueryResetFeaturesEXT>{ enum { value = true }; }; + template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceHostQueryResetFeaturesEXT>{ enum { value = true }; }; template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceIDProperties>{ enum { value = true }; }; template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, PhysicalDeviceImageDrmFormatModifierInfoEXT>{ enum { value = true }; }; template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, PhysicalDeviceImageViewImageFormatInfoEXT>{ enum { value = true }; }; @@ -54544,6 +55914,9 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid<PipelineColorBlendStateCreateInfo, PipelineColorBlendAdvancedStateCreateInfoEXT>{ enum { value = true }; }; template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineCoverageModulationStateCreateInfoNV>{ enum { value = true }; }; template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineCoverageToColorStateCreateInfoNV>{ enum { value = true }; }; + template <> struct isStructureChainValid<GraphicsPipelineCreateInfo, PipelineCreationFeedbackCreateInfoEXT>{ enum { value = true }; }; + template <> struct isStructureChainValid<ComputePipelineCreateInfo, PipelineCreationFeedbackCreateInfoEXT>{ enum { value = true }; }; + template <> struct isStructureChainValid<RayTracingPipelineCreateInfoNV, PipelineCreationFeedbackCreateInfoEXT>{ enum { value = true }; }; template <> struct isStructureChainValid<GraphicsPipelineCreateInfo, PipelineDiscardRectangleStateCreateInfoEXT>{ enum { value = true }; }; template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationConservativeStateCreateInfoEXT>{ enum { value = true }; }; template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationDepthClipStateCreateInfoEXT>{ enum { value = true }; }; @@ -54558,6 +55931,9 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportShadingRateImageStateCreateInfoNV>{ enum { value = true }; }; template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportSwizzleStateCreateInfoNV>{ enum { value = true }; }; template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportWScalingStateCreateInfoNV>{ enum { value = true }; }; +#ifdef VK_USE_PLATFORM_GGP + template <> struct isStructureChainValid<PresentInfoKHR, PresentFrameTokenGGP>{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_GGP*/ template <> struct isStructureChainValid<PresentInfoKHR, PresentRegionsKHR>{ enum { value = true }; }; template <> struct isStructureChainValid<PresentInfoKHR, PresentTimesInfoGOOGLE>{ enum { value = true }; }; template <> struct isStructureChainValid<SubmitInfo, ProtectedSubmitInfo>{ enum { value = true }; }; @@ -54574,7 +55950,20 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid<ShaderModuleCreateInfo, ShaderModuleValidationCacheCreateInfoEXT>{ enum { value = true }; }; template <> struct isStructureChainValid<SurfaceCapabilities2KHR, SharedPresentSurfaceCapabilitiesKHR>{ enum { value = true }; }; template <> struct isStructureChainValid<SubpassDescription2KHR, SubpassDescriptionDepthStencilResolveKHR>{ enum { value = true }; }; +#ifdef VK_USE_PLATFORM_WIN32_KHR + template <> struct isStructureChainValid<SurfaceCapabilities2KHR, SurfaceCapabilitiesFullScreenExclusiveEXT>{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template <> struct isStructureChainValid<PhysicalDeviceSurfaceInfo2KHR, SurfaceFullScreenExclusiveInfoEXT>{ enum { value = true }; }; + template <> struct isStructureChainValid<SwapchainCreateInfoKHR, SurfaceFullScreenExclusiveInfoEXT>{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#ifdef VK_USE_PLATFORM_WIN32_KHR + template <> struct isStructureChainValid<PhysicalDeviceSurfaceInfo2KHR, SurfaceFullScreenExclusiveWin32InfoEXT>{ enum { value = true }; }; + template <> struct isStructureChainValid<SwapchainCreateInfoKHR, SurfaceFullScreenExclusiveWin32InfoEXT>{ enum { value = true }; }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template <> struct isStructureChainValid<SurfaceCapabilities2KHR, SurfaceProtectedCapabilitiesKHR>{ enum { value = true }; }; template <> struct isStructureChainValid<SwapchainCreateInfoKHR, SwapchainCounterCreateInfoEXT>{ enum { value = true }; }; + template <> struct isStructureChainValid<SwapchainCreateInfoKHR, SwapchainDisplayNativeHdrCreateInfoAMD>{ enum { value = true }; }; template <> struct isStructureChainValid<ImageFormatProperties2, TextureLODGatherFormatPropertiesAMD>{ enum { value = true }; }; template <> struct isStructureChainValid<InstanceCreateInfo, ValidationFeaturesEXT>{ enum { value = true }; }; template <> struct isStructureChainValid<InstanceCreateInfo, ValidationFlagsEXT>{ enum { value = true }; }; @@ -54686,6 +56075,9 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0; PFN_vkEndCommandBuffer vkEndCommandBuffer = 0; PFN_vkResetCommandBuffer vkResetCommandBuffer = 0; +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0; PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0; PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0; @@ -54781,6 +56173,9 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0; PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = 0; PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0; +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = 0; PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0; PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0; @@ -54846,10 +56241,14 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0; PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0; PFN_vkRegisterObjectsNVX vkRegisterObjectsNVX = 0; +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ PFN_vkResetCommandPool vkResetCommandPool = 0; PFN_vkResetDescriptorPool vkResetDescriptorPool = 0; PFN_vkResetEvent vkResetEvent = 0; PFN_vkResetFences vkResetFences = 0; + PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = 0; PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0; PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0; PFN_vkSetEvent vkSetEvent = 0; @@ -54880,6 +56279,9 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_METAL_EXT PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0; #endif /*VK_USE_PLATFORM_METAL_EXT*/ +#ifdef VK_USE_PLATFORM_GGP + PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0; +#endif /*VK_USE_PLATFORM_GGP*/ #ifdef VK_USE_PLATFORM_VI_NN PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0; #endif /*VK_USE_PLATFORM_VI_NN*/ @@ -54959,6 +56361,9 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0; PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = 0; PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = 0; +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0; PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = 0; #ifdef VK_USE_PLATFORM_WAYLAND_KHR @@ -54985,15 +56390,30 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkQueuePresentKHR vkQueuePresentKHR = 0; PFN_vkQueueSubmit vkQueueSubmit = 0; PFN_vkQueueWaitIdle vkQueueWaitIdle = 0; + PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = 0; public: DispatchLoaderDynamic() = default; + // This interface is designed to be used for per-device function pointers in combination with a linked vulkan library. + DispatchLoaderDynamic(vk::Instance const& instance, vk::Device const& device = {}) + { + init(instance, device); + } + + // This interface is designed to be used for per-device function pointers in combination with a linked vulkan library. + void init(vk::Instance const& instance, vk::Device const& device = {}) + { + init(instance, ::vkGetInstanceProcAddr, device, device ? ::vkGetDeviceProcAddr : nullptr); + } + + // This interface does not require a linked vulkan library. DispatchLoaderDynamic( VkInstance instance, PFN_vkGetInstanceProcAddr getInstanceProcAddr, VkDevice device = VK_NULL_HANDLE, PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr ) { init( instance, getInstanceProcAddr, device, getDeviceProcAddr ); } + // This interface does not require a linked vulkan library. void init( VkInstance instance, PFN_vkGetInstanceProcAddr getInstanceProcAddr, VkDevice device = VK_NULL_HANDLE, PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr ) { assert(instance && getInstanceProcAddr); @@ -55096,6 +56516,9 @@ namespace VULKAN_HPP_NAMESPACE vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( device ? vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) : vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp" ) ); vkEndCommandBuffer = PFN_vkEndCommandBuffer( device ? vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) : vkGetInstanceProcAddr( instance, "vkEndCommandBuffer" ) ); vkResetCommandBuffer = PFN_vkResetCommandBuffer( device ? vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) : vkGetInstanceProcAddr( instance, "vkResetCommandBuffer" ) ); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( device ? vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) : vkGetInstanceProcAddr( instance, "vkAcquireFullScreenExclusiveModeEXT" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( device ? vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) : vkGetInstanceProcAddr( instance, "vkAcquireNextImage2KHR" ) ); vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( device ? vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) : vkGetInstanceProcAddr( instance, "vkAcquireNextImageKHR" ) ); vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( device ? vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) : vkGetInstanceProcAddr( instance, "vkAllocateCommandBuffers" ) ); @@ -55191,6 +56614,9 @@ namespace VULKAN_HPP_NAMESPACE vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeatures" ) ); vkGetDeviceGroupPeerMemoryFeaturesKHR = PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) ); vkGetDeviceGroupPresentCapabilitiesKHR = PFN_vkGetDeviceGroupPresentCapabilitiesKHR( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPresentCapabilitiesKHR" ) ); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkGetDeviceGroupSurfacePresentModes2EXT = PFN_vkGetDeviceGroupSurfacePresentModes2EXT( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModes2EXT" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ vkGetDeviceGroupSurfacePresentModesKHR = PFN_vkGetDeviceGroupSurfacePresentModesKHR( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModesKHR" ) ); vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( device ? vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryCommitment" ) ); vkGetDeviceQueue = PFN_vkGetDeviceQueue( device ? vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceQueue" ) ); @@ -55255,10 +56681,14 @@ namespace VULKAN_HPP_NAMESPACE vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( device ? vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) : vkGetInstanceProcAddr( instance, "vkRegisterDeviceEventEXT" ) ); vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( device ? vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) : vkGetInstanceProcAddr( instance, "vkRegisterDisplayEventEXT" ) ); vkRegisterObjectsNVX = PFN_vkRegisterObjectsNVX( device ? vkGetDeviceProcAddr( device, "vkRegisterObjectsNVX" ) : vkGetInstanceProcAddr( instance, "vkRegisterObjectsNVX" ) ); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( device ? vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) : vkGetInstanceProcAddr( instance, "vkReleaseFullScreenExclusiveModeEXT" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ vkResetCommandPool = PFN_vkResetCommandPool( device ? vkGetDeviceProcAddr( device, "vkResetCommandPool" ) : vkGetInstanceProcAddr( instance, "vkResetCommandPool" ) ); vkResetDescriptorPool = PFN_vkResetDescriptorPool( device ? vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) : vkGetInstanceProcAddr( instance, "vkResetDescriptorPool" ) ); vkResetEvent = PFN_vkResetEvent( device ? vkGetDeviceProcAddr( device, "vkResetEvent" ) : vkGetInstanceProcAddr( instance, "vkResetEvent" ) ); vkResetFences = PFN_vkResetFences( device ? vkGetDeviceProcAddr( device, "vkResetFences" ) : vkGetInstanceProcAddr( instance, "vkResetFences" ) ); + vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( device ? vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) : vkGetInstanceProcAddr( instance, "vkResetQueryPoolEXT" ) ); vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( device ? vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) : vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectNameEXT" ) ); vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( device ? vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) : vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectTagEXT" ) ); vkSetEvent = PFN_vkSetEvent( device ? vkGetDeviceProcAddr( device, "vkSetEvent" ) : vkGetInstanceProcAddr( instance, "vkSetEvent" ) ); @@ -55289,6 +56719,9 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_METAL_EXT vkCreateMetalSurfaceEXT = PFN_vkCreateMetalSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ) ); #endif /*VK_USE_PLATFORM_METAL_EXT*/ +#ifdef VK_USE_PLATFORM_GGP + vkCreateStreamDescriptorSurfaceGGP = PFN_vkCreateStreamDescriptorSurfaceGGP( vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ) ); +#endif /*VK_USE_PLATFORM_GGP*/ #ifdef VK_USE_PLATFORM_VI_NN vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN( vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ) ); #endif /*VK_USE_PLATFORM_VI_NN*/ @@ -55367,6 +56800,9 @@ namespace VULKAN_HPP_NAMESPACE vkGetPhysicalDeviceSurfaceCapabilitiesKHR = PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR" ) ); vkGetPhysicalDeviceSurfaceFormats2KHR = PFN_vkGetPhysicalDeviceSurfaceFormats2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormats2KHR" ) ); vkGetPhysicalDeviceSurfaceFormatsKHR = PFN_vkGetPhysicalDeviceSurfaceFormatsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormatsKHR" ) ); +#ifdef VK_USE_PLATFORM_WIN32_KHR + vkGetPhysicalDeviceSurfacePresentModes2EXT = PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ vkGetPhysicalDeviceSurfacePresentModesKHR = PFN_vkGetPhysicalDeviceSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModesKHR" ) ); vkGetPhysicalDeviceSurfaceSupportKHR = PFN_vkGetPhysicalDeviceSurfaceSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceSupportKHR" ) ); #ifdef VK_USE_PLATFORM_WAYLAND_KHR @@ -55393,6 +56829,7 @@ namespace VULKAN_HPP_NAMESPACE vkQueuePresentKHR = PFN_vkQueuePresentKHR( device ? vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) : vkGetInstanceProcAddr( instance, "vkQueuePresentKHR" ) ); vkQueueSubmit = PFN_vkQueueSubmit( device ? vkGetDeviceProcAddr( device, "vkQueueSubmit" ) : vkGetInstanceProcAddr( instance, "vkQueueSubmit" ) ); vkQueueWaitIdle = PFN_vkQueueWaitIdle( device ? vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) : vkGetInstanceProcAddr( instance, "vkQueueWaitIdle" ) ); + vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( device ? vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) : vkGetInstanceProcAddr( instance, "vkSetLocalDimmingAMD" ) ); } }; } // namespace VULKAN_HPP_NAMESPACE diff --git a/include/vulkan/vulkan_win32.h b/include/vulkan/vulkan_win32.h index d5e2741..a61a7d8 100644 --- a/include/vulkan/vulkan_win32.h +++ b/include/vulkan/vulkan_win32.h @@ -288,12 +288,6 @@ typedef struct VkSurfaceCapabilitiesFullScreenExclusiveEXT { VkBool32 fullScreenExclusiveSupported; } VkSurfaceCapabilitiesFullScreenExclusiveEXT; -typedef struct VkPhysicalDeviceSurfaceInfo2KHR { - VkStructureType sType; - const void* pNext; - VkSurfaceKHR surface; -} VkPhysicalDeviceSurfaceInfo2KHR; - typedef struct VkSurfaceFullScreenExclusiveWin32InfoEXT { VkStructureType sType; const void* pNext; diff --git a/registry/genvk.py b/registry/genvk.py index 5fbeb47..3d7f72d 100644 --- a/registry/genvk.py +++ b/registry/genvk.py @@ -250,7 +250,15 @@ def makeGenOpts(args): [ 'vulkan_macos.h', [ 'VK_MVK_macos_surface' ], commonSuppressExtensions ], [ 'vulkan_vi.h', [ 'VK_NN_vi_surface' ], commonSuppressExtensions ], [ 'vulkan_wayland.h', [ 'VK_KHR_wayland_surface' ], commonSuppressExtensions ], - [ 'vulkan_win32.h', [ 'VK_.*_win32(|_.*)', 'VK_EXT_full_screen_exclusive'], commonSuppressExtensions + [ 'VK_KHR_external_semaphore', 'VK_KHR_external_memory_capabilities', 'VK_KHR_external_fence', 'VK_KHR_external_fence_capabilities', 'VK_NV_external_memory_capabilities' ] ], + [ 'vulkan_win32.h', [ 'VK_.*_win32(|_.*)', 'VK_EXT_full_screen_exclusive' ], + commonSuppressExtensions + + [ 'VK_KHR_external_semaphore', + 'VK_KHR_external_memory_capabilities', + 'VK_KHR_external_fence', + 'VK_KHR_external_fence_capabilities', + 'VK_KHR_get_surface_capabilities2', + 'VK_NV_external_memory_capabilities', + ] ], [ 'vulkan_xcb.h', [ 'VK_KHR_xcb_surface' ], commonSuppressExtensions ], [ 'vulkan_xlib.h', [ 'VK_KHR_xlib_surface' ], commonSuppressExtensions ], [ 'vulkan_xlib_xrandr.h', [ 'VK_EXT_acquire_xlib_display' ], commonSuppressExtensions ], |