From b3ecf52eae1a02e25c4ad64f702f071772476d38 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20S=C3=BC=C3=9Fenbach?= Date: Mon, 19 Aug 2019 14:24:56 +0200 Subject: [PATCH] Update to version 1.1.120. (#374) --- Vulkan-Headers | 2 +- vulkan/vulkan.hpp | 1679 ++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 1673 insertions(+), 8 deletions(-) diff --git a/Vulkan-Headers b/Vulkan-Headers index 552e49e..4ee33d2 160000 --- a/Vulkan-Headers +++ b/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 552e49ee964e138352fbc0ecac3a16ca052ea7cb +Subproject commit 4ee33d2fbd1e7a072c4d8a6cf8f01c4f96d7483d diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index 38b17b9..a3fbd2a 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -56,7 +56,7 @@ # define VULKAN_HPP_ASSERT assert #endif -static_assert( VK_HEADER_VERSION == 116 , "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 120 , "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 @@ -1015,6 +1015,11 @@ namespace VULKAN_HPP_NAMESPACE return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors ); } + void vkCmdSetLineStippleEXT( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const + { + return ::vkCmdSetLineStippleEXT( commandBuffer, lineStippleFactor, lineStipplePattern ); + } + void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const { return ::vkCmdSetLineWidth( commandBuffer, lineWidth ); @@ -1751,6 +1756,21 @@ namespace VULKAN_HPP_NAMESPACE return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData ); } + VkResult vkGetPipelineExecutableInternalRepresentationsKHR( VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations ) const + { + return ::vkGetPipelineExecutableInternalRepresentationsKHR( device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations ); + } + + VkResult vkGetPipelineExecutablePropertiesKHR( VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties ) const + { + return ::vkGetPipelineExecutablePropertiesKHR( device, pPipelineInfo, pExecutableCount, pProperties ); + } + + VkResult vkGetPipelineExecutableStatisticsKHR( VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics ) const + { + return ::vkGetPipelineExecutableStatisticsKHR( device, pExecutableInfo, pStatisticCount, pStatistics ); + } + VkResult vkGetQueryPoolResults( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags ) const { return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags ); @@ -3403,7 +3423,8 @@ namespace VULKAN_HPP_NAMESPACE eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, eViewportShadingRatePaletteNV = VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV, eViewportCoarseSampleOrderNV = VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV, - eExclusiveScissorNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV + eExclusiveScissorNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV, + eLineStippleEXT = VK_DYNAMIC_STATE_LINE_STIPPLE_EXT }; VULKAN_HPP_INLINE std::string to_string( DynamicState value ) @@ -3425,6 +3446,7 @@ namespace VULKAN_HPP_NAMESPACE case DynamicState::eViewportShadingRatePaletteNV : return "ViewportShadingRatePaletteNV"; case DynamicState::eViewportCoarseSampleOrderNV : return "ViewportCoarseSampleOrderNV"; case DynamicState::eExclusiveScissorNV : return "ExclusiveScissorNV"; + case DynamicState::eLineStippleEXT : return "LineStippleEXT"; default: return "invalid"; } } @@ -3677,6 +3699,20 @@ namespace VULKAN_HPP_NAMESPACE ePvrtc14BppSrgbBlockIMG = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG, ePvrtc22BppSrgbBlockIMG = VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG, ePvrtc24BppSrgbBlockIMG = VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG, + eAstc4x4SfloatBlockEXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT, + eAstc5x4SfloatBlockEXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT, + eAstc5x5SfloatBlockEXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT, + eAstc6x5SfloatBlockEXT = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT, + eAstc6x6SfloatBlockEXT = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT, + eAstc8x5SfloatBlockEXT = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT, + eAstc8x6SfloatBlockEXT = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT, + eAstc8x8SfloatBlockEXT = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT, + eAstc10x5SfloatBlockEXT = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT, + eAstc10x6SfloatBlockEXT = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT, + eAstc10x8SfloatBlockEXT = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT, + eAstc10x10SfloatBlockEXT = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT, + eAstc12x10SfloatBlockEXT = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT, + eAstc12x12SfloatBlockEXT = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT, eG8B8G8R8422UnormKHR = VK_FORMAT_G8B8G8R8_422_UNORM_KHR, eB8G8R8G8422UnormKHR = VK_FORMAT_B8G8R8G8_422_UNORM_KHR, eG8B8R83Plane420UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR, @@ -3944,6 +3980,20 @@ namespace VULKAN_HPP_NAMESPACE case Format::ePvrtc14BppSrgbBlockIMG : return "Pvrtc14BppSrgbBlockIMG"; case Format::ePvrtc22BppSrgbBlockIMG : return "Pvrtc22BppSrgbBlockIMG"; case Format::ePvrtc24BppSrgbBlockIMG : return "Pvrtc24BppSrgbBlockIMG"; + case Format::eAstc4x4SfloatBlockEXT : return "Astc4x4SfloatBlockEXT"; + case Format::eAstc5x4SfloatBlockEXT : return "Astc5x4SfloatBlockEXT"; + case Format::eAstc5x5SfloatBlockEXT : return "Astc5x5SfloatBlockEXT"; + case Format::eAstc6x5SfloatBlockEXT : return "Astc6x5SfloatBlockEXT"; + case Format::eAstc6x6SfloatBlockEXT : return "Astc6x6SfloatBlockEXT"; + case Format::eAstc8x5SfloatBlockEXT : return "Astc8x5SfloatBlockEXT"; + case Format::eAstc8x6SfloatBlockEXT : return "Astc8x6SfloatBlockEXT"; + case Format::eAstc8x8SfloatBlockEXT : return "Astc8x8SfloatBlockEXT"; + case Format::eAstc10x5SfloatBlockEXT : return "Astc10x5SfloatBlockEXT"; + case Format::eAstc10x6SfloatBlockEXT : return "Astc10x6SfloatBlockEXT"; + case Format::eAstc10x8SfloatBlockEXT : return "Astc10x8SfloatBlockEXT"; + case Format::eAstc10x10SfloatBlockEXT : return "Astc10x10SfloatBlockEXT"; + case Format::eAstc12x10SfloatBlockEXT : return "Astc12x10SfloatBlockEXT"; + case Format::eAstc12x12SfloatBlockEXT : return "Astc12x12SfloatBlockEXT"; default: return "invalid"; } } @@ -4112,7 +4162,8 @@ namespace VULKAN_HPP_NAMESPACE { eUint16 = VK_INDEX_TYPE_UINT16, eUint32 = VK_INDEX_TYPE_UINT32, - eNoneNV = VK_INDEX_TYPE_NONE_NV + eNoneNV = VK_INDEX_TYPE_NONE_NV, + eUint8EXT = VK_INDEX_TYPE_UINT8_EXT }; VULKAN_HPP_INLINE std::string to_string( IndexType value ) @@ -4122,6 +4173,7 @@ namespace VULKAN_HPP_NAMESPACE case IndexType::eUint16 : return "Uint16"; case IndexType::eUint32 : return "Uint32"; case IndexType::eNoneNV : return "NoneNV"; + case IndexType::eUint8EXT : return "Uint8EXT"; default: return "invalid"; } } @@ -4168,6 +4220,26 @@ namespace VULKAN_HPP_NAMESPACE } } + enum class LineRasterizationModeEXT + { + eDefault = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, + eRectangular = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, + eBresenham = VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT, + eRectangularSmooth = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( LineRasterizationModeEXT value ) + { + switch ( value ) + { + case LineRasterizationModeEXT::eDefault : return "Default"; + case LineRasterizationModeEXT::eRectangular : return "Rectangular"; + case LineRasterizationModeEXT::eBresenham : return "Bresenham"; + case LineRasterizationModeEXT::eRectangularSmooth : return "RectangularSmooth"; + default: return "invalid"; + } + } + enum class LogicOp { eClear = VK_LOGIC_OP_CLEAR, @@ -4466,6 +4538,26 @@ namespace VULKAN_HPP_NAMESPACE } } + enum class PipelineExecutableStatisticFormatKHR + { + eBool32 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR, + eInt64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR, + eUint64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR, + eFloat64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( PipelineExecutableStatisticFormatKHR value ) + { + switch ( value ) + { + case PipelineExecutableStatisticFormatKHR::eBool32 : return "Bool32"; + case PipelineExecutableStatisticFormatKHR::eInt64 : return "Int64"; + case PipelineExecutableStatisticFormatKHR::eUint64 : return "Uint64"; + case PipelineExecutableStatisticFormatKHR::eFloat64 : return "Float64"; + default: return "invalid"; + } + } + enum class PointClippingBehavior { eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, @@ -5123,6 +5215,7 @@ namespace VULKAN_HPP_NAMESPACE eWin32KeyedMutexAcquireReleaseInfoNV = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV, eValidationFlagsEXT = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT, eViSurfaceCreateInfoNN = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN, + ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT, eImageViewAstcDecodeModeEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT, ePhysicalDeviceAstcDecodeFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, eImportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, @@ -5262,6 +5355,7 @@ namespace VULKAN_HPP_NAMESPACE eMemoryHostPointerPropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT, ePhysicalDeviceExternalMemoryHostPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT, ePhysicalDeviceShaderAtomicInt64FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR, + ePipelineCompilerControlCreateInfoAMD = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD, eCalibratedTimestampInfoEXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT, ePhysicalDeviceShaderCorePropertiesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD, eDeviceMemoryOverallocationCreateInfoAMD = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD, @@ -5302,6 +5396,8 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceScalarBlockLayoutFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT, ePhysicalDeviceSubgroupSizeControlPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT, ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT, + ePhysicalDeviceSubgroupSizeControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT, + ePhysicalDeviceShaderCoreProperties2AMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD, 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, @@ -5325,7 +5421,17 @@ namespace VULKAN_HPP_NAMESPACE eSurfaceCapabilitiesFullScreenExclusiveEXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT, eSurfaceFullScreenExclusiveWin32InfoEXT = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT, eHeadlessSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT, + ePhysicalDeviceLineRasterizationFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, + ePipelineRasterizationLineStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT, + ePhysicalDeviceLineRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT, ePhysicalDeviceHostQueryResetFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, + ePhysicalDeviceIndexTypeUint8FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, + ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, + ePipelineInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR, + ePipelineExecutablePropertiesKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR, + ePipelineExecutableInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR, + ePipelineExecutableStatisticKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR, + ePipelineExecutableInternalRepresentationKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR, ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT, ePhysicalDeviceTexelBufferAlignmentFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, ePhysicalDeviceTexelBufferAlignmentPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT, @@ -5552,6 +5658,7 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eWin32KeyedMutexAcquireReleaseInfoNV : return "Win32KeyedMutexAcquireReleaseInfoNV"; case StructureType::eValidationFlagsEXT : return "ValidationFlagsEXT"; case StructureType::eViSurfaceCreateInfoNN : return "ViSurfaceCreateInfoNN"; + case StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT : return "PhysicalDeviceTextureCompressionAstcHdrFeaturesEXT"; case StructureType::eImageViewAstcDecodeModeEXT : return "ImageViewAstcDecodeModeEXT"; case StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT : return "PhysicalDeviceAstcDecodeFeaturesEXT"; case StructureType::eImportMemoryWin32HandleInfoKHR : return "ImportMemoryWin32HandleInfoKHR"; @@ -5691,6 +5798,7 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eMemoryHostPointerPropertiesEXT : return "MemoryHostPointerPropertiesEXT"; case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT : return "PhysicalDeviceExternalMemoryHostPropertiesEXT"; case StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR : return "PhysicalDeviceShaderAtomicInt64FeaturesKHR"; + case StructureType::ePipelineCompilerControlCreateInfoAMD : return "PipelineCompilerControlCreateInfoAMD"; case StructureType::eCalibratedTimestampInfoEXT : return "CalibratedTimestampInfoEXT"; case StructureType::ePhysicalDeviceShaderCorePropertiesAMD : return "PhysicalDeviceShaderCorePropertiesAMD"; case StructureType::eDeviceMemoryOverallocationCreateInfoAMD : return "DeviceMemoryOverallocationCreateInfoAMD"; @@ -5731,6 +5839,8 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT : return "PhysicalDeviceScalarBlockLayoutFeaturesEXT"; case StructureType::ePhysicalDeviceSubgroupSizeControlPropertiesEXT : return "PhysicalDeviceSubgroupSizeControlPropertiesEXT"; case StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT : return "PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT"; + case StructureType::ePhysicalDeviceSubgroupSizeControlFeaturesEXT : return "PhysicalDeviceSubgroupSizeControlFeaturesEXT"; + case StructureType::ePhysicalDeviceShaderCoreProperties2AMD : return "PhysicalDeviceShaderCoreProperties2AMD"; case StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT : return "PhysicalDeviceMemoryBudgetPropertiesEXT"; case StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT : return "PhysicalDeviceMemoryPriorityFeaturesEXT"; case StructureType::eMemoryPriorityAllocateInfoEXT : return "MemoryPriorityAllocateInfoEXT"; @@ -5754,7 +5864,17 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT : return "SurfaceCapabilitiesFullScreenExclusiveEXT"; case StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT : return "SurfaceFullScreenExclusiveWin32InfoEXT"; case StructureType::eHeadlessSurfaceCreateInfoEXT : return "HeadlessSurfaceCreateInfoEXT"; + case StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT : return "PhysicalDeviceLineRasterizationFeaturesEXT"; + case StructureType::ePipelineRasterizationLineStateCreateInfoEXT : return "PipelineRasterizationLineStateCreateInfoEXT"; + case StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT : return "PhysicalDeviceLineRasterizationPropertiesEXT"; case StructureType::ePhysicalDeviceHostQueryResetFeaturesEXT : return "PhysicalDeviceHostQueryResetFeaturesEXT"; + case StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT : return "PhysicalDeviceIndexTypeUint8FeaturesEXT"; + case StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR : return "PhysicalDevicePipelineExecutablePropertiesFeaturesKHR"; + case StructureType::ePipelineInfoKHR : return "PipelineInfoKHR"; + case StructureType::ePipelineExecutablePropertiesKHR : return "PipelineExecutablePropertiesKHR"; + case StructureType::ePipelineExecutableInfoKHR : return "PipelineExecutableInfoKHR"; + case StructureType::ePipelineExecutableStatisticKHR : return "PipelineExecutableStatisticKHR"; + case StructureType::ePipelineExecutableInternalRepresentationKHR : return "PipelineExecutableInternalRepresentationKHR"; case StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT : return "PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT"; case StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT : return "PhysicalDeviceTexelBufferAlignmentFeaturesEXT"; case StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT : return "PhysicalDeviceTexelBufferAlignmentPropertiesEXT"; @@ -5897,7 +6017,8 @@ namespace VULKAN_HPP_NAMESPACE enum class ValidationFeatureEnableEXT { eGpuAssisted = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT, - eGpuAssistedReserveBindingSlot = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT + eGpuAssistedReserveBindingSlot = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT, + eBestPractices = VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT }; VULKAN_HPP_INLINE std::string to_string( ValidationFeatureEnableEXT value ) @@ -5906,6 +6027,7 @@ namespace VULKAN_HPP_NAMESPACE { case ValidationFeatureEnableEXT::eGpuAssisted : return "GpuAssisted"; case ValidationFeatureEnableEXT::eGpuAssistedReserveBindingSlot : return "GpuAssistedReserveBindingSlot"; + case ValidationFeatureEnableEXT::eBestPractices : return "BestPractices"; default: return "invalid"; } } @@ -8928,6 +9050,21 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; } + enum class PipelineCompilerControlFlagBitsAMD + {}; + + VULKAN_HPP_INLINE std::string to_string( PipelineCompilerControlFlagBitsAMD ) + { + return "(void)"; + } + + using PipelineCompilerControlFlagsAMD = Flags; + + VULKAN_HPP_INLINE std::string to_string( PipelineCompilerControlFlagsAMD ) + { + return "{}"; + } + enum class PipelineCoverageModulationStateCreateFlagBitsNV {}; @@ -8981,6 +9118,8 @@ namespace VULKAN_HPP_NAMESPACE eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE, eDeferCompileNV = VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV, + eCaptureStatisticsKHR = VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR, + eCaptureInternalRepresentationsKHR = VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR, eViewIndexFromDeviceIndexKHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR, eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE_KHR }; @@ -8995,6 +9134,8 @@ namespace VULKAN_HPP_NAMESPACE case PipelineCreateFlagBits::eViewIndexFromDeviceIndex : return "ViewIndexFromDeviceIndex"; case PipelineCreateFlagBits::eDispatchBase : return "DispatchBase"; case PipelineCreateFlagBits::eDeferCompileNV : return "DeferCompileNV"; + case PipelineCreateFlagBits::eCaptureStatisticsKHR : return "CaptureStatisticsKHR"; + case PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR : return "CaptureInternalRepresentationsKHR"; default: return "invalid"; } } @@ -9015,7 +9156,7 @@ namespace VULKAN_HPP_NAMESPACE { enum { - allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndex) | VkFlags(PipelineCreateFlagBits::eDispatchBase) | VkFlags(PipelineCreateFlagBits::eDeferCompileNV) + allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndex) | VkFlags(PipelineCreateFlagBits::eDispatchBase) | VkFlags(PipelineCreateFlagBits::eDeferCompileNV) | VkFlags(PipelineCreateFlagBits::eCaptureStatisticsKHR) | VkFlags(PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR) }; }; @@ -9030,6 +9171,8 @@ namespace VULKAN_HPP_NAMESPACE if ( value & PipelineCreateFlagBits::eViewIndexFromDeviceIndex ) result += "ViewIndexFromDeviceIndex | "; if ( value & PipelineCreateFlagBits::eDispatchBase ) result += "DispatchBase | "; if ( value & PipelineCreateFlagBits::eDeferCompileNV ) result += "DeferCompileNV | "; + if ( value & PipelineCreateFlagBits::eCaptureStatisticsKHR ) result += "CaptureStatisticsKHR | "; + if ( value & PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR ) result += "CaptureInternalRepresentationsKHR | "; return "{ " + result.substr(0, result.size() - 3) + " }"; } @@ -9931,6 +10074,21 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + enum class ShaderCorePropertiesFlagBitsAMD + {}; + + VULKAN_HPP_INLINE std::string to_string( ShaderCorePropertiesFlagBitsAMD ) + { + return "(void)"; + } + + using ShaderCorePropertiesFlagsAMD = Flags; + + VULKAN_HPP_INLINE std::string to_string( ShaderCorePropertiesFlagsAMD ) + { + return "{}"; + } + enum class ShaderModuleCreateFlagBits {}; @@ -10128,6 +10286,7 @@ namespace VULKAN_HPP_NAMESPACE { eFront = VK_STENCIL_FACE_FRONT_BIT, eBack = VK_STENCIL_FACE_BACK_BIT, + eFrontAndBack = VK_STENCIL_FACE_FRONT_AND_BACK, eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK }; @@ -10137,7 +10296,7 @@ namespace VULKAN_HPP_NAMESPACE { case StencilFaceFlagBits::eFront : return "Front"; case StencilFaceFlagBits::eBack : return "Back"; - case StencilFaceFlagBits::eVkStencilFrontAndBack : return "VkStencilFrontAndBack"; + case StencilFaceFlagBits::eFrontAndBack : return "FrontAndBack"; default: return "invalid"; } } @@ -10158,7 +10317,7 @@ namespace VULKAN_HPP_NAMESPACE { enum { - allFlags = VkFlags(StencilFaceFlagBits::eFront) | VkFlags(StencilFaceFlagBits::eBack) | VkFlags(StencilFaceFlagBits::eVkStencilFrontAndBack) + allFlags = VkFlags(StencilFaceFlagBits::eFront) | VkFlags(StencilFaceFlagBits::eBack) | VkFlags(StencilFaceFlagBits::eFrontAndBack) }; }; @@ -11387,9 +11546,12 @@ namespace VULKAN_HPP_NAMESPACE using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2; struct PhysicalDeviceImageViewImageFormatInfoEXT; struct PhysicalDeviceImagelessFramebufferFeaturesKHR; + struct PhysicalDeviceIndexTypeUint8FeaturesEXT; struct PhysicalDeviceInlineUniformBlockFeaturesEXT; struct PhysicalDeviceInlineUniformBlockPropertiesEXT; struct PhysicalDeviceLimits; + struct PhysicalDeviceLineRasterizationFeaturesEXT; + struct PhysicalDeviceLineRasterizationPropertiesEXT; struct PhysicalDeviceMaintenance3Properties; using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties; struct PhysicalDeviceMemoryBudgetPropertiesEXT; @@ -11405,6 +11567,7 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceMultiviewProperties; using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties; struct PhysicalDevicePCIBusInfoPropertiesEXT; + struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR; struct PhysicalDevicePointClippingProperties; using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties; struct PhysicalDeviceProperties; @@ -11421,6 +11584,7 @@ namespace VULKAN_HPP_NAMESPACE using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures; struct PhysicalDeviceScalarBlockLayoutFeaturesEXT; struct PhysicalDeviceShaderAtomicInt64FeaturesKHR; + struct PhysicalDeviceShaderCoreProperties2AMD; struct PhysicalDeviceShaderCorePropertiesAMD; struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; struct PhysicalDeviceShaderDrawParametersFeatures; @@ -11437,10 +11601,12 @@ namespace VULKAN_HPP_NAMESPACE using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2; struct PhysicalDeviceSparseProperties; struct PhysicalDeviceSubgroupProperties; + struct PhysicalDeviceSubgroupSizeControlFeaturesEXT; struct PhysicalDeviceSubgroupSizeControlPropertiesEXT; struct PhysicalDeviceSurfaceInfo2KHR; struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT; struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT; + struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT; struct PhysicalDeviceTransformFeedbackFeaturesEXT; struct PhysicalDeviceTransformFeedbackPropertiesEXT; struct PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR; @@ -11456,6 +11622,7 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineColorBlendAdvancedStateCreateInfoEXT; struct PipelineColorBlendAttachmentState; struct PipelineColorBlendStateCreateInfo; + struct PipelineCompilerControlCreateInfoAMD; struct PipelineCoverageModulationStateCreateInfoNV; struct PipelineCoverageReductionStateCreateInfoNV; struct PipelineCoverageToColorStateCreateInfoNV; @@ -11464,11 +11631,18 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineDepthStencilStateCreateInfo; struct PipelineDiscardRectangleStateCreateInfoEXT; struct PipelineDynamicStateCreateInfo; + struct PipelineExecutableInfoKHR; + struct PipelineExecutableInternalRepresentationKHR; + struct PipelineExecutablePropertiesKHR; + struct PipelineExecutableStatisticKHR; + union PipelineExecutableStatisticValueKHR; + struct PipelineInfoKHR; struct PipelineInputAssemblyStateCreateInfo; struct PipelineLayoutCreateInfo; struct PipelineMultisampleStateCreateInfo; struct PipelineRasterizationConservativeStateCreateInfoEXT; struct PipelineRasterizationDepthClipStateCreateInfoEXT; + struct PipelineRasterizationLineStateCreateInfoEXT; struct PipelineRasterizationStateCreateInfo; struct PipelineRasterizationStateRasterizationOrderAMD; struct PipelineRasterizationStateStreamCreateInfoEXT; @@ -13381,6 +13555,9 @@ namespace VULKAN_HPP_NAMESPACE void setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy exclusiveScissors, Dispatch const &d = Dispatch() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + void setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const &d = Dispatch() ) const; + template void setLineWidth( float lineWidth, Dispatch const &d = Dispatch() ) const; @@ -16098,6 +16275,33 @@ namespace VULKAN_HPP_NAMESPACE typename ResultValueType>::type getPipelineCacheData( vk::PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + Result getPipelineExecutableInternalRepresentationsKHR( const vk::PipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, vk::PipelineExecutableInternalRepresentationKHR* pInternalRepresentations, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template, typename Dispatch = DispatchLoaderDefault> + typename ResultValueType>::type getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const &d = Dispatch() ) const; + template, typename Dispatch = DispatchLoaderDefault> + typename ResultValueType>::type getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, Allocator const& vectorAllocator, Dispatch const &d ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getPipelineExecutablePropertiesKHR( const vk::PipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, vk::PipelineExecutablePropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template, typename Dispatch = DispatchLoaderDefault> + typename ResultValueType>::type getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Dispatch const &d = Dispatch() ) const; + template, typename Dispatch = DispatchLoaderDefault> + typename ResultValueType>::type getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Allocator const& vectorAllocator, Dispatch const &d ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + Result getPipelineExecutableStatisticsKHR( const vk::PipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, vk::PipelineExecutableStatisticKHR* pStatistics, Dispatch const &d = Dispatch() ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template, typename Dispatch = DispatchLoaderDefault> + typename ResultValueType>::type getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const &d = Dispatch() ) const; + template, typename Dispatch = DispatchLoaderDefault> + typename ResultValueType>::type getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Allocator const& vectorAllocator, Dispatch const &d ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template Result getQueryPoolResults( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d = Dispatch() ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -46066,6 +46270,90 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PhysicalDeviceImagelessFramebufferFeaturesKHR ) == sizeof( VkPhysicalDeviceImagelessFramebufferFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + namespace layout + { + struct PhysicalDeviceIndexTypeUint8FeaturesEXT + { + protected: + PhysicalDeviceIndexTypeUint8FeaturesEXT( vk::Bool32 indexTypeUint8_ = 0 ) + : indexTypeUint8( indexTypeUint8_ ) + {} + + PhysicalDeviceIndexTypeUint8FeaturesEXT( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) + { + *reinterpret_cast(this) = rhs; + } + + PhysicalDeviceIndexTypeUint8FeaturesEXT& operator=( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + public: + vk::StructureType sType = StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT; + void* pNext = nullptr; + vk::Bool32 indexTypeUint8; + }; + static_assert( sizeof( PhysicalDeviceIndexTypeUint8FeaturesEXT ) == sizeof( VkPhysicalDeviceIndexTypeUint8FeaturesEXT ), "layout struct and wrapper have different size!" ); + } + + struct PhysicalDeviceIndexTypeUint8FeaturesEXT : public layout::PhysicalDeviceIndexTypeUint8FeaturesEXT + { + PhysicalDeviceIndexTypeUint8FeaturesEXT( vk::Bool32 indexTypeUint8_ = 0 ) + : layout::PhysicalDeviceIndexTypeUint8FeaturesEXT( indexTypeUint8_ ) + {} + + PhysicalDeviceIndexTypeUint8FeaturesEXT( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) + : layout::PhysicalDeviceIndexTypeUint8FeaturesEXT( rhs ) + {} + + PhysicalDeviceIndexTypeUint8FeaturesEXT& operator=( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + PhysicalDeviceIndexTypeUint8FeaturesEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceIndexTypeUint8FeaturesEXT & setIndexTypeUint8( vk::Bool32 indexTypeUint8_ ) + { + indexTypeUint8 = indexTypeUint8_; + return *this; + } + + operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceIndexTypeUint8FeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( indexTypeUint8 == rhs.indexTypeUint8 ); + } + + bool operator!=( PhysicalDeviceIndexTypeUint8FeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + using layout::PhysicalDeviceIndexTypeUint8FeaturesEXT::sType; + }; + static_assert( sizeof( PhysicalDeviceIndexTypeUint8FeaturesEXT ) == sizeof( VkPhysicalDeviceIndexTypeUint8FeaturesEXT ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + namespace layout { struct PhysicalDeviceInlineUniformBlockFeaturesEXT @@ -46473,6 +46761,203 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + namespace layout + { + struct PhysicalDeviceLineRasterizationFeaturesEXT + { + protected: + PhysicalDeviceLineRasterizationFeaturesEXT( vk::Bool32 rectangularLines_ = 0, + vk::Bool32 bresenhamLines_ = 0, + vk::Bool32 smoothLines_ = 0, + vk::Bool32 stippledRectangularLines_ = 0, + vk::Bool32 stippledBresenhamLines_ = 0, + vk::Bool32 stippledSmoothLines_ = 0 ) + : rectangularLines( rectangularLines_ ) + , bresenhamLines( bresenhamLines_ ) + , smoothLines( smoothLines_ ) + , stippledRectangularLines( stippledRectangularLines_ ) + , stippledBresenhamLines( stippledBresenhamLines_ ) + , stippledSmoothLines( stippledSmoothLines_ ) + {} + + PhysicalDeviceLineRasterizationFeaturesEXT( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) + { + *reinterpret_cast(this) = rhs; + } + + PhysicalDeviceLineRasterizationFeaturesEXT& operator=( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + public: + vk::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 rectangularLines; + vk::Bool32 bresenhamLines; + vk::Bool32 smoothLines; + vk::Bool32 stippledRectangularLines; + vk::Bool32 stippledBresenhamLines; + vk::Bool32 stippledSmoothLines; + }; + static_assert( sizeof( PhysicalDeviceLineRasterizationFeaturesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationFeaturesEXT ), "layout struct and wrapper have different size!" ); + } + + struct PhysicalDeviceLineRasterizationFeaturesEXT : public layout::PhysicalDeviceLineRasterizationFeaturesEXT + { + PhysicalDeviceLineRasterizationFeaturesEXT( vk::Bool32 rectangularLines_ = 0, + vk::Bool32 bresenhamLines_ = 0, + vk::Bool32 smoothLines_ = 0, + vk::Bool32 stippledRectangularLines_ = 0, + vk::Bool32 stippledBresenhamLines_ = 0, + vk::Bool32 stippledSmoothLines_ = 0 ) + : layout::PhysicalDeviceLineRasterizationFeaturesEXT( rectangularLines_, bresenhamLines_, smoothLines_, stippledRectangularLines_, stippledBresenhamLines_, stippledSmoothLines_ ) + {} + + PhysicalDeviceLineRasterizationFeaturesEXT( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) + : layout::PhysicalDeviceLineRasterizationFeaturesEXT( rhs ) + {} + + PhysicalDeviceLineRasterizationFeaturesEXT& operator=( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + PhysicalDeviceLineRasterizationFeaturesEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceLineRasterizationFeaturesEXT & setRectangularLines( vk::Bool32 rectangularLines_ ) + { + rectangularLines = rectangularLines_; + return *this; + } + + PhysicalDeviceLineRasterizationFeaturesEXT & setBresenhamLines( vk::Bool32 bresenhamLines_ ) + { + bresenhamLines = bresenhamLines_; + return *this; + } + + PhysicalDeviceLineRasterizationFeaturesEXT & setSmoothLines( vk::Bool32 smoothLines_ ) + { + smoothLines = smoothLines_; + return *this; + } + + PhysicalDeviceLineRasterizationFeaturesEXT & setStippledRectangularLines( vk::Bool32 stippledRectangularLines_ ) + { + stippledRectangularLines = stippledRectangularLines_; + return *this; + } + + PhysicalDeviceLineRasterizationFeaturesEXT & setStippledBresenhamLines( vk::Bool32 stippledBresenhamLines_ ) + { + stippledBresenhamLines = stippledBresenhamLines_; + return *this; + } + + PhysicalDeviceLineRasterizationFeaturesEXT & setStippledSmoothLines( vk::Bool32 stippledSmoothLines_ ) + { + stippledSmoothLines = stippledSmoothLines_; + return *this; + } + + operator VkPhysicalDeviceLineRasterizationFeaturesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLineRasterizationFeaturesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceLineRasterizationFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( rectangularLines == rhs.rectangularLines ) + && ( bresenhamLines == rhs.bresenhamLines ) + && ( smoothLines == rhs.smoothLines ) + && ( stippledRectangularLines == rhs.stippledRectangularLines ) + && ( stippledBresenhamLines == rhs.stippledBresenhamLines ) + && ( stippledSmoothLines == rhs.stippledSmoothLines ); + } + + bool operator!=( PhysicalDeviceLineRasterizationFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + using layout::PhysicalDeviceLineRasterizationFeaturesEXT::sType; + }; + static_assert( sizeof( PhysicalDeviceLineRasterizationFeaturesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationFeaturesEXT ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + namespace layout + { + struct PhysicalDeviceLineRasterizationPropertiesEXT + { + protected: + PhysicalDeviceLineRasterizationPropertiesEXT( uint32_t lineSubPixelPrecisionBits_ = 0 ) + : lineSubPixelPrecisionBits( lineSubPixelPrecisionBits_ ) + {} + + PhysicalDeviceLineRasterizationPropertiesEXT( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) + { + *reinterpret_cast(this) = rhs; + } + + PhysicalDeviceLineRasterizationPropertiesEXT& operator=( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + public: + vk::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT; + void* pNext = nullptr; + uint32_t lineSubPixelPrecisionBits; + }; + static_assert( sizeof( PhysicalDeviceLineRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationPropertiesEXT ), "layout struct and wrapper have different size!" ); + } + + struct PhysicalDeviceLineRasterizationPropertiesEXT : public layout::PhysicalDeviceLineRasterizationPropertiesEXT + { + operator VkPhysicalDeviceLineRasterizationPropertiesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLineRasterizationPropertiesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceLineRasterizationPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( lineSubPixelPrecisionBits == rhs.lineSubPixelPrecisionBits ); + } + + bool operator!=( PhysicalDeviceLineRasterizationPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + using layout::PhysicalDeviceLineRasterizationPropertiesEXT::sType; + }; + static_assert( sizeof( PhysicalDeviceLineRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationPropertiesEXT ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + namespace layout { struct PhysicalDeviceMaintenance3Properties @@ -47274,6 +47759,90 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PhysicalDevicePCIBusInfoPropertiesEXT ) == sizeof( VkPhysicalDevicePCIBusInfoPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + namespace layout + { + struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR + { + protected: + PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( vk::Bool32 pipelineExecutableInfo_ = 0 ) + : pipelineExecutableInfo( pipelineExecutableInfo_ ) + {} + + PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) + { + *reinterpret_cast(this) = rhs; + } + + PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + public: + vk::StructureType sType = StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 pipelineExecutableInfo; + }; + static_assert( sizeof( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) == sizeof( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR ), "layout struct and wrapper have different size!" ); + } + + struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR : public layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR + { + PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( vk::Bool32 pipelineExecutableInfo_ = 0 ) + : layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( pipelineExecutableInfo_ ) + {} + + PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) + : layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( rhs ) + {} + + PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & setPipelineExecutableInfo( vk::Bool32 pipelineExecutableInfo_ ) + { + pipelineExecutableInfo = pipelineExecutableInfo_; + return *this; + } + + operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( pipelineExecutableInfo == rhs.pipelineExecutableInfo ); + } + + bool operator!=( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + using layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::sType; + }; + static_assert( sizeof( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) == sizeof( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + namespace layout { struct PhysicalDevicePointClippingProperties @@ -48241,6 +48810,68 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + namespace layout + { + struct PhysicalDeviceShaderCoreProperties2AMD + { + protected: + PhysicalDeviceShaderCoreProperties2AMD( vk::ShaderCorePropertiesFlagsAMD shaderCoreFeatures_ = vk::ShaderCorePropertiesFlagsAMD(), + uint32_t activeComputeUnitCount_ = 0 ) + : shaderCoreFeatures( shaderCoreFeatures_ ) + , activeComputeUnitCount( activeComputeUnitCount_ ) + {} + + PhysicalDeviceShaderCoreProperties2AMD( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) + { + *reinterpret_cast(this) = rhs; + } + + PhysicalDeviceShaderCoreProperties2AMD& operator=( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + public: + vk::StructureType sType = StructureType::ePhysicalDeviceShaderCoreProperties2AMD; + void* pNext = nullptr; + vk::ShaderCorePropertiesFlagsAMD shaderCoreFeatures; + uint32_t activeComputeUnitCount; + }; + static_assert( sizeof( PhysicalDeviceShaderCoreProperties2AMD ) == sizeof( VkPhysicalDeviceShaderCoreProperties2AMD ), "layout struct and wrapper have different size!" ); + } + + struct PhysicalDeviceShaderCoreProperties2AMD : public layout::PhysicalDeviceShaderCoreProperties2AMD + { + operator VkPhysicalDeviceShaderCoreProperties2AMD const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderCoreProperties2AMD &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceShaderCoreProperties2AMD const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( shaderCoreFeatures == rhs.shaderCoreFeatures ) + && ( activeComputeUnitCount == rhs.activeComputeUnitCount ); + } + + bool operator!=( PhysicalDeviceShaderCoreProperties2AMD const& rhs ) const + { + return !operator==( rhs ); + } + + private: + using layout::PhysicalDeviceShaderCoreProperties2AMD::sType; + }; + static_assert( sizeof( PhysicalDeviceShaderCoreProperties2AMD ) == sizeof( VkPhysicalDeviceShaderCoreProperties2AMD ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + namespace layout { struct PhysicalDeviceShaderCorePropertiesAMD @@ -49287,6 +49918,101 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PhysicalDeviceSubgroupProperties ) == sizeof( VkPhysicalDeviceSubgroupProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + namespace layout + { + struct PhysicalDeviceSubgroupSizeControlFeaturesEXT + { + protected: + PhysicalDeviceSubgroupSizeControlFeaturesEXT( vk::Bool32 subgroupSizeControl_ = 0, + vk::Bool32 computeFullSubgroups_ = 0 ) + : subgroupSizeControl( subgroupSizeControl_ ) + , computeFullSubgroups( computeFullSubgroups_ ) + {} + + PhysicalDeviceSubgroupSizeControlFeaturesEXT( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) + { + *reinterpret_cast(this) = rhs; + } + + PhysicalDeviceSubgroupSizeControlFeaturesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + public: + vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 subgroupSizeControl; + vk::Bool32 computeFullSubgroups; + }; + static_assert( sizeof( PhysicalDeviceSubgroupSizeControlFeaturesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT ), "layout struct and wrapper have different size!" ); + } + + struct PhysicalDeviceSubgroupSizeControlFeaturesEXT : public layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT + { + PhysicalDeviceSubgroupSizeControlFeaturesEXT( vk::Bool32 subgroupSizeControl_ = 0, + vk::Bool32 computeFullSubgroups_ = 0 ) + : layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT( subgroupSizeControl_, computeFullSubgroups_ ) + {} + + PhysicalDeviceSubgroupSizeControlFeaturesEXT( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) + : layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT( rhs ) + {} + + PhysicalDeviceSubgroupSizeControlFeaturesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + PhysicalDeviceSubgroupSizeControlFeaturesEXT & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceSubgroupSizeControlFeaturesEXT & setSubgroupSizeControl( vk::Bool32 subgroupSizeControl_ ) + { + subgroupSizeControl = subgroupSizeControl_; + return *this; + } + + PhysicalDeviceSubgroupSizeControlFeaturesEXT & setComputeFullSubgroups( vk::Bool32 computeFullSubgroups_ ) + { + computeFullSubgroups = computeFullSubgroups_; + return *this; + } + + operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceSubgroupSizeControlFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( subgroupSizeControl == rhs.subgroupSizeControl ) + && ( computeFullSubgroups == rhs.computeFullSubgroups ); + } + + bool operator!=( PhysicalDeviceSubgroupSizeControlFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + using layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT::sType; + }; + static_assert( sizeof( PhysicalDeviceSubgroupSizeControlFeaturesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + namespace layout { struct PhysicalDeviceSubgroupSizeControlPropertiesEXT @@ -49595,6 +50321,90 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentPropertiesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + namespace layout + { + struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT + { + protected: + PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( vk::Bool32 textureCompressionASTC_HDR_ = 0 ) + : textureCompressionASTC_HDR( textureCompressionASTC_HDR_ ) + {} + + PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) + { + *reinterpret_cast(this) = rhs; + } + + PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + public: + vk::StructureType sType = StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT; + const void* pNext = nullptr; + vk::Bool32 textureCompressionASTC_HDR; + }; + static_assert( sizeof( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) == sizeof( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ), "layout struct and wrapper have different size!" ); + } + + struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT : public layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT + { + PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( vk::Bool32 textureCompressionASTC_HDR_ = 0 ) + : layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( textureCompressionASTC_HDR_ ) + {} + + PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) + : layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( rhs ) + {} + + PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & setTextureCompressionASTC_HDR( vk::Bool32 textureCompressionASTC_HDR_ ) + { + textureCompressionASTC_HDR = textureCompressionASTC_HDR_; + return *this; + } + + operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( textureCompressionASTC_HDR == rhs.textureCompressionASTC_HDR ); + } + + bool operator!=( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + using layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::sType; + }; + static_assert( sizeof( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) == sizeof( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + namespace layout { struct PhysicalDeviceTransformFeedbackFeaturesEXT @@ -50518,6 +51328,90 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + namespace layout + { + struct PipelineCompilerControlCreateInfoAMD + { + protected: + PipelineCompilerControlCreateInfoAMD( vk::PipelineCompilerControlFlagsAMD compilerControlFlags_ = vk::PipelineCompilerControlFlagsAMD() ) + : compilerControlFlags( compilerControlFlags_ ) + {} + + PipelineCompilerControlCreateInfoAMD( VkPipelineCompilerControlCreateInfoAMD const & rhs ) + { + *reinterpret_cast(this) = rhs; + } + + PipelineCompilerControlCreateInfoAMD& operator=( VkPipelineCompilerControlCreateInfoAMD const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + public: + vk::StructureType sType = StructureType::ePipelineCompilerControlCreateInfoAMD; + const void* pNext = nullptr; + vk::PipelineCompilerControlFlagsAMD compilerControlFlags; + }; + static_assert( sizeof( PipelineCompilerControlCreateInfoAMD ) == sizeof( VkPipelineCompilerControlCreateInfoAMD ), "layout struct and wrapper have different size!" ); + } + + struct PipelineCompilerControlCreateInfoAMD : public layout::PipelineCompilerControlCreateInfoAMD + { + PipelineCompilerControlCreateInfoAMD( vk::PipelineCompilerControlFlagsAMD compilerControlFlags_ = vk::PipelineCompilerControlFlagsAMD() ) + : layout::PipelineCompilerControlCreateInfoAMD( compilerControlFlags_ ) + {} + + PipelineCompilerControlCreateInfoAMD( VkPipelineCompilerControlCreateInfoAMD const & rhs ) + : layout::PipelineCompilerControlCreateInfoAMD( rhs ) + {} + + PipelineCompilerControlCreateInfoAMD& operator=( VkPipelineCompilerControlCreateInfoAMD const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + PipelineCompilerControlCreateInfoAMD & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineCompilerControlCreateInfoAMD & setCompilerControlFlags( vk::PipelineCompilerControlFlagsAMD compilerControlFlags_ ) + { + compilerControlFlags = compilerControlFlags_; + return *this; + } + + operator VkPipelineCompilerControlCreateInfoAMD const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCompilerControlCreateInfoAMD &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PipelineCompilerControlCreateInfoAMD const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( compilerControlFlags == rhs.compilerControlFlags ); + } + + bool operator!=( PipelineCompilerControlCreateInfoAMD const& rhs ) const + { + return !operator==( rhs ); + } + + private: + using layout::PipelineCompilerControlCreateInfoAMD::sType; + }; + static_assert( sizeof( PipelineCompilerControlCreateInfoAMD ) == sizeof( VkPipelineCompilerControlCreateInfoAMD ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + namespace layout { struct PipelineCoverageModulationStateCreateInfoNV @@ -51100,6 +51994,469 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + namespace layout + { + struct PipelineExecutableInfoKHR + { + protected: + PipelineExecutableInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline(), + uint32_t executableIndex_ = 0 ) + : pipeline( pipeline_ ) + , executableIndex( executableIndex_ ) + {} + + PipelineExecutableInfoKHR( VkPipelineExecutableInfoKHR const & rhs ) + { + *reinterpret_cast(this) = rhs; + } + + PipelineExecutableInfoKHR& operator=( VkPipelineExecutableInfoKHR const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + public: + vk::StructureType sType = StructureType::ePipelineExecutableInfoKHR; + const void* pNext = nullptr; + vk::Pipeline pipeline; + uint32_t executableIndex; + }; + static_assert( sizeof( PipelineExecutableInfoKHR ) == sizeof( VkPipelineExecutableInfoKHR ), "layout struct and wrapper have different size!" ); + } + + struct PipelineExecutableInfoKHR : public layout::PipelineExecutableInfoKHR + { + PipelineExecutableInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline(), + uint32_t executableIndex_ = 0 ) + : layout::PipelineExecutableInfoKHR( pipeline_, executableIndex_ ) + {} + + PipelineExecutableInfoKHR( VkPipelineExecutableInfoKHR const & rhs ) + : layout::PipelineExecutableInfoKHR( rhs ) + {} + + PipelineExecutableInfoKHR& operator=( VkPipelineExecutableInfoKHR const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + PipelineExecutableInfoKHR & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineExecutableInfoKHR & setPipeline( vk::Pipeline pipeline_ ) + { + pipeline = pipeline_; + return *this; + } + + PipelineExecutableInfoKHR & setExecutableIndex( uint32_t executableIndex_ ) + { + executableIndex = executableIndex_; + return *this; + } + + operator VkPipelineExecutableInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineExecutableInfoKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PipelineExecutableInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( pipeline == rhs.pipeline ) + && ( executableIndex == rhs.executableIndex ); + } + + bool operator!=( PipelineExecutableInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + using layout::PipelineExecutableInfoKHR::sType; + }; + static_assert( sizeof( PipelineExecutableInfoKHR ) == sizeof( VkPipelineExecutableInfoKHR ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + namespace layout + { + struct PipelineExecutableInternalRepresentationKHR + { + protected: + PipelineExecutableInternalRepresentationKHR( std::array const& name_ = { { 0 } }, + std::array const& description_ = { { 0 } }, + vk::Bool32 isText_ = 0, + size_t dataSize_ = 0, + void* pData_ = nullptr ) + : isText( isText_ ) + , dataSize( dataSize_ ) + , pData( pData_ ) + { + memcpy( &name, name_.data(), VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ); + memcpy( &description, description_.data(), VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ); + + } + + PipelineExecutableInternalRepresentationKHR( VkPipelineExecutableInternalRepresentationKHR const & rhs ) + { + *reinterpret_cast(this) = rhs; + } + + PipelineExecutableInternalRepresentationKHR& operator=( VkPipelineExecutableInternalRepresentationKHR const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + public: + vk::StructureType sType = StructureType::ePipelineExecutableInternalRepresentationKHR; + void* pNext = nullptr; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + vk::Bool32 isText; + size_t dataSize; + void* pData; + }; + static_assert( sizeof( PipelineExecutableInternalRepresentationKHR ) == sizeof( VkPipelineExecutableInternalRepresentationKHR ), "layout struct and wrapper have different size!" ); + } + + struct PipelineExecutableInternalRepresentationKHR : public layout::PipelineExecutableInternalRepresentationKHR + { + PipelineExecutableInternalRepresentationKHR( std::array const& name_ = { { 0 } }, + std::array const& description_ = { { 0 } }, + vk::Bool32 isText_ = 0, + size_t dataSize_ = 0, + void* pData_ = nullptr ) + : layout::PipelineExecutableInternalRepresentationKHR( name_, description_, isText_, dataSize_, pData_ ) + {} + + PipelineExecutableInternalRepresentationKHR( VkPipelineExecutableInternalRepresentationKHR const & rhs ) + : layout::PipelineExecutableInternalRepresentationKHR( rhs ) + {} + + PipelineExecutableInternalRepresentationKHR& operator=( VkPipelineExecutableInternalRepresentationKHR const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + PipelineExecutableInternalRepresentationKHR & setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineExecutableInternalRepresentationKHR & setName( std::array name_ ) + { + memcpy( name, name_.data(), VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ); + return *this; + } + + PipelineExecutableInternalRepresentationKHR & setDescription( std::array description_ ) + { + memcpy( description, description_.data(), VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ); + return *this; + } + + PipelineExecutableInternalRepresentationKHR & setIsText( vk::Bool32 isText_ ) + { + isText = isText_; + return *this; + } + + PipelineExecutableInternalRepresentationKHR & setDataSize( size_t dataSize_ ) + { + dataSize = dataSize_; + return *this; + } + + PipelineExecutableInternalRepresentationKHR & setPData( void* pData_ ) + { + pData = pData_; + return *this; + } + + operator VkPipelineExecutableInternalRepresentationKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineExecutableInternalRepresentationKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PipelineExecutableInternalRepresentationKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memcmp( name, rhs.name, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 ) + && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 ) + && ( isText == rhs.isText ) + && ( dataSize == rhs.dataSize ) + && ( pData == rhs.pData ); + } + + bool operator!=( PipelineExecutableInternalRepresentationKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + using layout::PipelineExecutableInternalRepresentationKHR::sType; + }; + static_assert( sizeof( PipelineExecutableInternalRepresentationKHR ) == sizeof( VkPipelineExecutableInternalRepresentationKHR ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + namespace layout + { + struct PipelineExecutablePropertiesKHR + { + protected: + PipelineExecutablePropertiesKHR( vk::ShaderStageFlags stages_ = vk::ShaderStageFlags(), + std::array const& name_ = { { 0 } }, + std::array const& description_ = { { 0 } }, + uint32_t subgroupSize_ = 0 ) + : stages( stages_ ) + , subgroupSize( subgroupSize_ ) + { + memcpy( &name, name_.data(), VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ); + memcpy( &description, description_.data(), VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ); + + } + + PipelineExecutablePropertiesKHR( VkPipelineExecutablePropertiesKHR const & rhs ) + { + *reinterpret_cast(this) = rhs; + } + + PipelineExecutablePropertiesKHR& operator=( VkPipelineExecutablePropertiesKHR const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + public: + vk::StructureType sType = StructureType::ePipelineExecutablePropertiesKHR; + void* pNext = nullptr; + vk::ShaderStageFlags stages; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + uint32_t subgroupSize; + }; + static_assert( sizeof( PipelineExecutablePropertiesKHR ) == sizeof( VkPipelineExecutablePropertiesKHR ), "layout struct and wrapper have different size!" ); + } + + struct PipelineExecutablePropertiesKHR : public layout::PipelineExecutablePropertiesKHR + { + operator VkPipelineExecutablePropertiesKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineExecutablePropertiesKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PipelineExecutablePropertiesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( stages == rhs.stages ) + && ( memcmp( name, rhs.name, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 ) + && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 ) + && ( subgroupSize == rhs.subgroupSize ); + } + + bool operator!=( PipelineExecutablePropertiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + using layout::PipelineExecutablePropertiesKHR::sType; + }; + static_assert( sizeof( PipelineExecutablePropertiesKHR ) == sizeof( VkPipelineExecutablePropertiesKHR ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + union PipelineExecutableStatisticValueKHR + { + operator VkPipelineExecutableStatisticValueKHR const&() const + { + return *reinterpret_cast(this); + } + + operator VkPipelineExecutableStatisticValueKHR &() + { + return *reinterpret_cast(this); + } + +#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS + vk::Bool32 b32; + int64_t i64; + uint64_t u64; + double f64; +#else + VkBool32 b32; + int64_t i64; + uint64_t u64; + double f64; +#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ + }; + + namespace layout + { + struct PipelineExecutableStatisticKHR + { + protected: + PipelineExecutableStatisticKHR( std::array const& name_ = { { 0 } }, + std::array const& description_ = { { 0 } }, + vk::PipelineExecutableStatisticFormatKHR format_ = vk::PipelineExecutableStatisticFormatKHR::eBool32, + vk::PipelineExecutableStatisticValueKHR value_ = vk::PipelineExecutableStatisticValueKHR() ) + : format( format_ ) + , value( value_ ) + { + memcpy( &name, name_.data(), VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ); + memcpy( &description, description_.data(), VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ); + + } + + PipelineExecutableStatisticKHR( VkPipelineExecutableStatisticKHR const & rhs ) + { + *reinterpret_cast(this) = rhs; + } + + PipelineExecutableStatisticKHR& operator=( VkPipelineExecutableStatisticKHR const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + public: + vk::StructureType sType = StructureType::ePipelineExecutableStatisticKHR; + void* pNext = nullptr; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + vk::PipelineExecutableStatisticFormatKHR format; + vk::PipelineExecutableStatisticValueKHR value; + }; + static_assert( sizeof( PipelineExecutableStatisticKHR ) == sizeof( VkPipelineExecutableStatisticKHR ), "layout struct and wrapper have different size!" ); + } + + struct PipelineExecutableStatisticKHR : public layout::PipelineExecutableStatisticKHR + { + operator VkPipelineExecutableStatisticKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineExecutableStatisticKHR &() + { + return *reinterpret_cast( this ); + } + + private: + using layout::PipelineExecutableStatisticKHR::sType; + }; + static_assert( sizeof( PipelineExecutableStatisticKHR ) == sizeof( VkPipelineExecutableStatisticKHR ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + namespace layout + { + struct PipelineInfoKHR + { + protected: + PipelineInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline() ) + : pipeline( pipeline_ ) + {} + + PipelineInfoKHR( VkPipelineInfoKHR const & rhs ) + { + *reinterpret_cast(this) = rhs; + } + + PipelineInfoKHR& operator=( VkPipelineInfoKHR const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + public: + vk::StructureType sType = StructureType::ePipelineInfoKHR; + const void* pNext = nullptr; + vk::Pipeline pipeline; + }; + static_assert( sizeof( PipelineInfoKHR ) == sizeof( VkPipelineInfoKHR ), "layout struct and wrapper have different size!" ); + } + + struct PipelineInfoKHR : public layout::PipelineInfoKHR + { + PipelineInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline() ) + : layout::PipelineInfoKHR( pipeline_ ) + {} + + PipelineInfoKHR( VkPipelineInfoKHR const & rhs ) + : layout::PipelineInfoKHR( rhs ) + {} + + PipelineInfoKHR& operator=( VkPipelineInfoKHR const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + PipelineInfoKHR & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineInfoKHR & setPipeline( vk::Pipeline pipeline_ ) + { + pipeline = pipeline_; + return *this; + } + + operator VkPipelineInfoKHR const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineInfoKHR &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PipelineInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( pipeline == rhs.pipeline ); + } + + bool operator!=( PipelineInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + using layout::PipelineInfoKHR::sType; + }; + static_assert( sizeof( PipelineInfoKHR ) == sizeof( VkPipelineInfoKHR ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + struct PushConstantRange { PushConstantRange( vk::ShaderStageFlags stageFlags_ = vk::ShaderStageFlags(), @@ -51498,6 +52855,123 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationDepthClipStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + namespace layout + { + struct PipelineRasterizationLineStateCreateInfoEXT + { + protected: + PipelineRasterizationLineStateCreateInfoEXT( vk::LineRasterizationModeEXT lineRasterizationMode_ = vk::LineRasterizationModeEXT::eDefault, + vk::Bool32 stippledLineEnable_ = 0, + uint32_t lineStippleFactor_ = 0, + uint16_t lineStipplePattern_ = 0 ) + : lineRasterizationMode( lineRasterizationMode_ ) + , stippledLineEnable( stippledLineEnable_ ) + , lineStippleFactor( lineStippleFactor_ ) + , lineStipplePattern( lineStipplePattern_ ) + {} + + PipelineRasterizationLineStateCreateInfoEXT( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) + { + *reinterpret_cast(this) = rhs; + } + + PipelineRasterizationLineStateCreateInfoEXT& operator=( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + public: + vk::StructureType sType = StructureType::ePipelineRasterizationLineStateCreateInfoEXT; + const void* pNext = nullptr; + vk::LineRasterizationModeEXT lineRasterizationMode; + vk::Bool32 stippledLineEnable; + uint32_t lineStippleFactor; + uint16_t lineStipplePattern; + }; + static_assert( sizeof( PipelineRasterizationLineStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationLineStateCreateInfoEXT ), "layout struct and wrapper have different size!" ); + } + + struct PipelineRasterizationLineStateCreateInfoEXT : public layout::PipelineRasterizationLineStateCreateInfoEXT + { + PipelineRasterizationLineStateCreateInfoEXT( vk::LineRasterizationModeEXT lineRasterizationMode_ = vk::LineRasterizationModeEXT::eDefault, + vk::Bool32 stippledLineEnable_ = 0, + uint32_t lineStippleFactor_ = 0, + uint16_t lineStipplePattern_ = 0 ) + : layout::PipelineRasterizationLineStateCreateInfoEXT( lineRasterizationMode_, stippledLineEnable_, lineStippleFactor_, lineStipplePattern_ ) + {} + + PipelineRasterizationLineStateCreateInfoEXT( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) + : layout::PipelineRasterizationLineStateCreateInfoEXT( rhs ) + {} + + PipelineRasterizationLineStateCreateInfoEXT& operator=( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) + { + *reinterpret_cast(this) = rhs; + return *this; + } + + PipelineRasterizationLineStateCreateInfoEXT & setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineRasterizationLineStateCreateInfoEXT & setLineRasterizationMode( vk::LineRasterizationModeEXT lineRasterizationMode_ ) + { + lineRasterizationMode = lineRasterizationMode_; + return *this; + } + + PipelineRasterizationLineStateCreateInfoEXT & setStippledLineEnable( vk::Bool32 stippledLineEnable_ ) + { + stippledLineEnable = stippledLineEnable_; + return *this; + } + + PipelineRasterizationLineStateCreateInfoEXT & setLineStippleFactor( uint32_t lineStippleFactor_ ) + { + lineStippleFactor = lineStippleFactor_; + return *this; + } + + PipelineRasterizationLineStateCreateInfoEXT & setLineStipplePattern( uint16_t lineStipplePattern_ ) + { + lineStipplePattern = lineStipplePattern_; + return *this; + } + + operator VkPipelineRasterizationLineStateCreateInfoEXT const&() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationLineStateCreateInfoEXT &() + { + return *reinterpret_cast( this ); + } + + bool operator==( PipelineRasterizationLineStateCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( lineRasterizationMode == rhs.lineRasterizationMode ) + && ( stippledLineEnable == rhs.stippledLineEnable ) + && ( lineStippleFactor == rhs.lineStippleFactor ) + && ( lineStipplePattern == rhs.lineStipplePattern ); + } + + bool operator!=( PipelineRasterizationLineStateCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + using layout::PipelineRasterizationLineStateCreateInfoEXT::sType; + }; + static_assert( sizeof( PipelineRasterizationLineStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationLineStateCreateInfoEXT ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + namespace layout { struct PipelineRasterizationStateRasterizationOrderAMD @@ -61649,6 +63123,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const &d) const + { + d.vkCmdSetLineStippleEXT( m_commandBuffer, lineStippleFactor, lineStipplePattern ); + } +#else + template + VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const &d ) const + { + d.vkCmdSetLineStippleEXT( m_commandBuffer, lineStippleFactor, lineStipplePattern ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const &d) const @@ -64926,6 +66414,162 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + VULKAN_HPP_INLINE Result Device::getPipelineExecutableInternalRepresentationsKHR( const vk::PipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, vk::PipelineExecutableInternalRepresentationKHR* pInternalRepresentations, Dispatch const &d) const + { + return static_cast( d.vkGetPipelineExecutableInternalRepresentationsKHR( m_device, reinterpret_cast( pExecutableInfo ), pInternalRepresentationCount, reinterpret_cast( pInternalRepresentations ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const &d ) const + { + std::vector internalRepresentations; + uint32_t internalRepresentationCount; + Result result; + do + { + result = static_cast( d.vkGetPipelineExecutableInternalRepresentationsKHR( m_device, reinterpret_cast( &executableInfo ), &internalRepresentationCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && internalRepresentationCount ) + { + internalRepresentations.resize( internalRepresentationCount ); + result = static_cast( d.vkGetPipelineExecutableInternalRepresentationsKHR( m_device, reinterpret_cast( &executableInfo ), &internalRepresentationCount, reinterpret_cast( internalRepresentations.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() ); + internalRepresentations.resize( internalRepresentationCount ); + } + return createResultValue( result, internalRepresentations, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineExecutableInternalRepresentationsKHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector internalRepresentations( vectorAllocator ); + uint32_t internalRepresentationCount; + Result result; + do + { + result = static_cast( d.vkGetPipelineExecutableInternalRepresentationsKHR( m_device, reinterpret_cast( &executableInfo ), &internalRepresentationCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && internalRepresentationCount ) + { + internalRepresentations.resize( internalRepresentationCount ); + result = static_cast( d.vkGetPipelineExecutableInternalRepresentationsKHR( m_device, reinterpret_cast( &executableInfo ), &internalRepresentationCount, reinterpret_cast( internalRepresentations.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() ); + internalRepresentations.resize( internalRepresentationCount ); + } + return createResultValue( result, internalRepresentations, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineExecutableInternalRepresentationsKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::getPipelineExecutablePropertiesKHR( const vk::PipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, vk::PipelineExecutablePropertiesKHR* pProperties, Dispatch const &d) const + { + return static_cast( d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast( pPipelineInfo ), pExecutableCount, reinterpret_cast( pProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Dispatch const &d ) const + { + std::vector properties; + uint32_t executableCount; + Result result; + do + { + result = static_cast( d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast( &pipelineInfo ), &executableCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && executableCount ) + { + properties.resize( executableCount ); + result = static_cast( d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast( &pipelineInfo ), &executableCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( executableCount <= properties.size() ); + properties.resize( executableCount ); + } + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineExecutablePropertiesKHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector properties( vectorAllocator ); + uint32_t executableCount; + Result result; + do + { + result = static_cast( d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast( &pipelineInfo ), &executableCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && executableCount ) + { + properties.resize( executableCount ); + result = static_cast( d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast( &pipelineInfo ), &executableCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( executableCount <= properties.size() ); + properties.resize( executableCount ); + } + return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineExecutablePropertiesKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + template + VULKAN_HPP_INLINE Result Device::getPipelineExecutableStatisticsKHR( const vk::PipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, vk::PipelineExecutableStatisticKHR* pStatistics, Dispatch const &d) const + { + return static_cast( d.vkGetPipelineExecutableStatisticsKHR( m_device, reinterpret_cast( pExecutableInfo ), pStatisticCount, reinterpret_cast( pStatistics ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const &d ) const + { + std::vector statistics; + uint32_t statisticCount; + Result result; + do + { + result = static_cast( d.vkGetPipelineExecutableStatisticsKHR( m_device, reinterpret_cast( &executableInfo ), &statisticCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && statisticCount ) + { + statistics.resize( statisticCount ); + result = static_cast( d.vkGetPipelineExecutableStatisticsKHR( m_device, reinterpret_cast( &executableInfo ), &statisticCount, reinterpret_cast( statistics.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( statisticCount <= statistics.size() ); + statistics.resize( statisticCount ); + } + return createResultValue( result, statistics, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineExecutableStatisticsKHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector statistics( vectorAllocator ); + uint32_t statisticCount; + Result result; + do + { + result = static_cast( d.vkGetPipelineExecutableStatisticsKHR( m_device, reinterpret_cast( &executableInfo ), &statisticCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && statisticCount ) + { + statistics.resize( statisticCount ); + result = static_cast( d.vkGetPipelineExecutableStatisticsKHR( m_device, reinterpret_cast( &executableInfo ), &statisticCount, reinterpret_cast( statistics.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( statisticCount <= statistics.size() ); + statistics.resize( statisticCount ); + } + return createResultValue( result, statistics, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineExecutableStatisticsKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template VULKAN_HPP_INLINE Result Device::getQueryPoolResults( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d) const { @@ -68471,9 +70115,14 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -68502,6 +70151,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -68520,10 +70170,14 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -68539,6 +70193,8 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -68548,6 +70204,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -68688,6 +70345,7 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0; PFN_vkCmdSetEvent vkCmdSetEvent = 0; PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0; + PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0; PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0; PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = 0; PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = 0; @@ -68848,6 +70506,9 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0; PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL = 0; PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0; + PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0; + PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR = 0; + PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = 0; PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0; PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0; PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0; @@ -69142,6 +70803,7 @@ namespace VULKAN_HPP_NAMESPACE vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( device ? vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEXT" ) ); vkCmdSetEvent = PFN_vkCmdSetEvent( device ? vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) : vkGetInstanceProcAddr( instance, "vkCmdSetEvent" ) ); vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( device ? vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) : vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorNV" ) ); + vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( device ? vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEXT" ) ); vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( device ? vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) : vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) ); vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( device ? vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) : vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceMarkerINTEL" ) ); vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( device ? vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) : vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceOverrideINTEL" ) ); @@ -69301,6 +70963,9 @@ namespace VULKAN_HPP_NAMESPACE vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( device ? vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) : vkGetInstanceProcAddr( instance, "vkGetPastPresentationTimingGOOGLE" ) ); vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( device ? vkGetDeviceProcAddr( device, "vkGetPerformanceParameterINTEL" ) : vkGetInstanceProcAddr( instance, "vkGetPerformanceParameterINTEL" ) ); vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( device ? vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) : vkGetInstanceProcAddr( instance, "vkGetPipelineCacheData" ) ); + vkGetPipelineExecutableInternalRepresentationsKHR = PFN_vkGetPipelineExecutableInternalRepresentationsKHR( device ? vkGetDeviceProcAddr( device, "vkGetPipelineExecutableInternalRepresentationsKHR" ) : vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableInternalRepresentationsKHR" ) ); + vkGetPipelineExecutablePropertiesKHR = PFN_vkGetPipelineExecutablePropertiesKHR( device ? vkGetDeviceProcAddr( device, "vkGetPipelineExecutablePropertiesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetPipelineExecutablePropertiesKHR" ) ); + vkGetPipelineExecutableStatisticsKHR = PFN_vkGetPipelineExecutableStatisticsKHR( device ? vkGetDeviceProcAddr( device, "vkGetPipelineExecutableStatisticsKHR" ) : vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableStatisticsKHR" ) ); vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( device ? vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) : vkGetInstanceProcAddr( instance, "vkGetQueryPoolResults" ) ); vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( device ? vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) : vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesNV" ) ); vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( device ? vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) : vkGetInstanceProcAddr( instance, "vkGetRefreshCycleDurationGOOGLE" ) );