BeeEngine/vulkan-headers
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update for Vulkan-Docs 1.4.327

Browse source
This commit is contained in:
Jon Leech 2025-09-19 14:44:16 +01:00 • committed by Jon Leech
parent d1cd37e925
commit d7a7044334
15 changed files with 12272 additions and 750 deletions
Download patch file Download diff file Expand all files Collapse all files

31
include/vulkan/vulkan.cppm
View file

@ -814,6 +814,14 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagsQNX; using VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagsQNX;
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
//=== VK_VALVE_video_encode_rgb_conversion ===
using VULKAN_HPP_NAMESPACE::VideoEncodeRgbChromaOffsetFlagBitsVALVE;
using VULKAN_HPP_NAMESPACE::VideoEncodeRgbChromaOffsetFlagsVALVE;
using VULKAN_HPP_NAMESPACE::VideoEncodeRgbModelConversionFlagBitsVALVE;
using VULKAN_HPP_NAMESPACE::VideoEncodeRgbModelConversionFlagsVALVE;
using VULKAN_HPP_NAMESPACE::VideoEncodeRgbRangeCompressionFlagBitsVALVE;
using VULKAN_HPP_NAMESPACE::VideoEncodeRgbRangeCompressionFlagsVALVE;
//=== VK_EXT_opacity_micromap === //=== VK_EXT_opacity_micromap ===
using VULKAN_HPP_NAMESPACE::BuildMicromapFlagBitsEXT; using VULKAN_HPP_NAMESPACE::BuildMicromapFlagBitsEXT;
using VULKAN_HPP_NAMESPACE::BuildMicromapFlagsEXT; using VULKAN_HPP_NAMESPACE::BuildMicromapFlagsEXT;
@ -2360,6 +2368,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::EXTGlobalPriorityQuerySpecVersion; using VULKAN_HPP_NAMESPACE::EXTGlobalPriorityQuerySpecVersion;
using VULKAN_HPP_NAMESPACE::MaxGlobalPrioritySizeEXT; using VULKAN_HPP_NAMESPACE::MaxGlobalPrioritySizeEXT;
//=== VK_VALVE_video_encode_rgb_conversion ===
using VULKAN_HPP_NAMESPACE::VALVEVideoEncodeRgbConversionExtensionName;
using VULKAN_HPP_NAMESPACE::VALVEVideoEncodeRgbConversionSpecVersion;
//=== VK_EXT_image_view_min_lod === //=== VK_EXT_image_view_min_lod ===
using VULKAN_HPP_NAMESPACE::EXTImageViewMinLodExtensionName; using VULKAN_HPP_NAMESPACE::EXTImageViewMinLodExtensionName;
using VULKAN_HPP_NAMESPACE::EXTImageViewMinLodSpecVersion; using VULKAN_HPP_NAMESPACE::EXTImageViewMinLodSpecVersion;
@ -4476,6 +4488,12 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_KHR_shader_untyped_pointers === //=== VK_KHR_shader_untyped_pointers ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUntypedPointersFeaturesKHR; using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUntypedPointersFeaturesKHR;
//=== VK_VALVE_video_encode_rgb_conversion ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE;
using VULKAN_HPP_NAMESPACE::VideoEncodeProfileRgbConversionInfoVALVE;
using VULKAN_HPP_NAMESPACE::VideoEncodeRgbConversionCapabilitiesVALVE;
using VULKAN_HPP_NAMESPACE::VideoEncodeSessionRgbConversionCreateInfoVALVE;
//=== VK_EXT_image_view_min_lod === //=== VK_EXT_image_view_min_lod ===
using VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT; using VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT; using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT;
@ -5487,6 +5505,9 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::SharedHandleTraits; using VULKAN_HPP_NAMESPACE::SharedHandleTraits;
using VULKAN_HPP_NAMESPACE::SharedIndirectCommandsLayoutEXT; using VULKAN_HPP_NAMESPACE::SharedIndirectCommandsLayoutEXT;
using VULKAN_HPP_NAMESPACE::SharedIndirectExecutionSetEXT; using VULKAN_HPP_NAMESPACE::SharedIndirectExecutionSetEXT;
//=== VK_KHR_swapchain enum ===
using VULKAN_HPP_NAMESPACE::SwapchainOwns;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
//=========================== //===========================
@ -8069,6 +8090,16 @@ export namespace std
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUntypedPointersFeaturesKHR>; struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUntypedPointersFeaturesKHR>;
//=== VK_VALVE_video_encode_rgb_conversion ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRgbConversionCapabilitiesVALVE>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeProfileRgbConversionInfoVALVE>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeSessionRgbConversionCreateInfoVALVE>;
//=== VK_EXT_image_view_min_lod === //=== VK_EXT_image_view_min_lod ===
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT>; struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT>;

55
include/vulkan/vulkan.hpp
View file

@ -12,7 +12,8 @@
#if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) #if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE )
# include <cassert> # include <cassert>
# include <string.h> # include <cstdlib>
# include <cstring>
import VULKAN_HPP_STD_MODULE; import VULKAN_HPP_STD_MODULE;
#else #else
# include <algorithm> # include <algorithm>
@ -56,7 +57,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# endif # endif
#endif #endif
static_assert( VK_HEADER_VERSION == 326, "Wrong VK_HEADER_VERSION!" ); static_assert( VK_HEADER_VERSION == 327, "Wrong VK_HEADER_VERSION!" );
// <tuple> includes <sys/sysmacros.h> through some other header // <tuple> includes <sys/sysmacros.h> through some other header
// this results in major(x) being resolved to gnu_dev_major(x) // this results in major(x) being resolved to gnu_dev_major(x)
@ -8882,6 +8883,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityQueryExtensionName = VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityQueryExtensionName = VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityQuerySpecVersion = VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION; VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityQuerySpecVersion = VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION;
//=== VK_VALVE_video_encode_rgb_conversion ===
VULKAN_HPP_CONSTEXPR_INLINE auto VALVEVideoEncodeRgbConversionExtensionName = VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto VALVEVideoEncodeRgbConversionSpecVersion = VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_SPEC_VERSION;
//=== VK_EXT_image_view_min_lod === //=== VK_EXT_image_view_min_lod ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageViewMinLodExtensionName = VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageViewMinLodExtensionName = VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageViewMinLodSpecVersion = VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION; VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageViewMinLodSpecVersion = VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION;
@ -15672,6 +15677,52 @@ namespace VULKAN_HPP_NAMESPACE
}; };
}; };
//=== VK_VALVE_video_encode_rgb_conversion ===
template <>
struct StructExtends<PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeRgbConversionCapabilitiesVALVE, VideoCapabilitiesKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeProfileRgbConversionInfoVALVE, VideoProfileInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeSessionRgbConversionCreateInfoVALVE, VideoSessionCreateInfoKHR>
{
enum
{
value = true
};
};
//=== VK_EXT_image_view_min_lod === //=== VK_EXT_image_view_min_lod ===
template <> template <>
struct StructExtends<PhysicalDeviceImageViewMinLodFeaturesEXT, PhysicalDeviceFeatures2> struct StructExtends<PhysicalDeviceImageViewMinLodFeaturesEXT, PhysicalDeviceFeatures2>

68
include/vulkan/vulkan_core.h
View file

@ -69,7 +69,7 @@ extern "C" {
#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
// Version of this file // Version of this file
#define VK_HEADER_VERSION 326 #define VK_HEADER_VERSION 327
// Complete version of this file // Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@ -970,6 +970,10 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT = 1000382000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT = 1000382000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR = 1000386000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR = 1000386000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR = 1000387000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR = 1000387000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE = 1000390000,
VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE = 1000390001,
VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE = 1000390002,
VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE = 1000390003,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT = 1000391000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT = 1000391000,
VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT = 1000391001, VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT = 1000391001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000,
@ -7543,7 +7547,7 @@ typedef struct VkPhysicalDeviceSubgroupSizeControlProperties {
typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo { typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo {
VkStructureType sType; VkStructureType sType;
void* pNext; const void* pNext;
uint32_t requiredSubgroupSize; uint32_t requiredSubgroupSize;
} VkPipelineShaderStageRequiredSubgroupSizeCreateInfo; } VkPipelineShaderStageRequiredSubgroupSizeCreateInfo;
@ -19359,6 +19363,66 @@ typedef VkQueueFamilyGlobalPriorityProperties VkQueueFamilyGlobalPriorityPropert
// VK_VALVE_video_encode_rgb_conversion is a preprocessor guard. Do not pass it to API calls.
#define VK_VALVE_video_encode_rgb_conversion 1
#define VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_SPEC_VERSION 1
#define VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME "VK_VALVE_video_encode_rgb_conversion"
typedef enum VkVideoEncodeRgbModelConversionFlagBitsVALVE {
VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE = 0x00000001,
VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE = 0x00000002,
VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE = 0x00000004,
VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE = 0x00000008,
VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE = 0x00000010,
VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_FLAG_BITS_MAX_ENUM_VALVE = 0x7FFFFFFF
} VkVideoEncodeRgbModelConversionFlagBitsVALVE;
typedef VkFlags VkVideoEncodeRgbModelConversionFlagsVALVE;
typedef enum VkVideoEncodeRgbRangeCompressionFlagBitsVALVE {
VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE = 0x00000001,
VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE = 0x00000002,
VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FLAG_BITS_MAX_ENUM_VALVE = 0x7FFFFFFF
} VkVideoEncodeRgbRangeCompressionFlagBitsVALVE;
typedef VkFlags VkVideoEncodeRgbRangeCompressionFlagsVALVE;
typedef enum VkVideoEncodeRgbChromaOffsetFlagBitsVALVE {
VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE = 0x00000001,
VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE = 0x00000002,
VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_FLAG_BITS_MAX_ENUM_VALVE = 0x7FFFFFFF
} VkVideoEncodeRgbChromaOffsetFlagBitsVALVE;
typedef VkFlags VkVideoEncodeRgbChromaOffsetFlagsVALVE;
typedef struct VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE {
VkStructureType sType;
void* pNext;
VkBool32 videoEncodeRgbConversion;
} VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE;
typedef struct VkVideoEncodeRgbConversionCapabilitiesVALVE {
VkStructureType sType;
void* pNext;
VkVideoEncodeRgbModelConversionFlagsVALVE rgbModels;
VkVideoEncodeRgbRangeCompressionFlagsVALVE rgbRanges;
VkVideoEncodeRgbChromaOffsetFlagsVALVE xChromaOffsets;
VkVideoEncodeRgbChromaOffsetFlagsVALVE yChromaOffsets;
} VkVideoEncodeRgbConversionCapabilitiesVALVE;
typedef struct VkVideoEncodeProfileRgbConversionInfoVALVE {
VkStructureType sType;
const void* pNext;
VkBool32 performEncodeRgbConversion;
} VkVideoEncodeProfileRgbConversionInfoVALVE;
typedef struct VkVideoEncodeSessionRgbConversionCreateInfoVALVE {
VkStructureType sType;
const void* pNext;
VkVideoEncodeRgbModelConversionFlagBitsVALVE rgbModel;
VkVideoEncodeRgbRangeCompressionFlagBitsVALVE rgbRange;
VkVideoEncodeRgbChromaOffsetFlagBitsVALVE xChromaOffset;
VkVideoEncodeRgbChromaOffsetFlagBitsVALVE yChromaOffset;
} VkVideoEncodeSessionRgbConversionCreateInfoVALVE;
// VK_EXT_image_view_min_lod is a preprocessor guard. Do not pass it to API calls. // VK_EXT_image_view_min_lod is a preprocessor guard. Do not pass it to API calls.
#define VK_EXT_image_view_min_lod 1 #define VK_EXT_image_view_min_lod 1
#define VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION 1 #define VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION 1

120
include/vulkan/vulkan_enums.hpp
View file

@ -9,7 +9,7 @@
#define VULKAN_ENUMS_HPP #define VULKAN_ENUMS_HPP
// include-what-you-use: make sure, vulkan.hpp is used by code-completers // include-what-you-use: make sure, vulkan.hpp is used by code-completers
// IWYU pragma: private; include "vulkan.hpp" // IWYU pragma: private, include "vulkan/vulkan.hpp"
#include <type_traits> // for std::underlying_type #include <type_traits> // for std::underlying_type
@ -1312,28 +1312,32 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_USE_PLATFORM_SCREEN_QNX ) #if defined( VK_USE_PLATFORM_SCREEN_QNX )
eScreenSurfaceCreateInfoQNX = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX, eScreenSurfaceCreateInfoQNX = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX,
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
ePhysicalDeviceColorWriteEnableFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT, ePhysicalDeviceColorWriteEnableFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT,
ePipelineColorWriteCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT, ePipelineColorWriteCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT,
ePhysicalDevicePrimitivesGeneratedQueryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, ePhysicalDevicePrimitivesGeneratedQueryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT,
ePhysicalDeviceRayTracingMaintenance1FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR, ePhysicalDeviceRayTracingMaintenance1FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR,
ePhysicalDeviceShaderUntypedPointersFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR, ePhysicalDeviceShaderUntypedPointersFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR,
ePhysicalDeviceImageViewMinLodFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT, ePhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE,
eImageViewMinLodCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT, eVideoEncodeRgbConversionCapabilitiesVALVE = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE,
ePhysicalDeviceMultiDrawFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT, eVideoEncodeProfileRgbConversionInfoVALVE = VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE,
ePhysicalDeviceMultiDrawPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT, eVideoEncodeSessionRgbConversionCreateInfoVALVE = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE,
ePhysicalDeviceImage2DViewOf3DFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, ePhysicalDeviceImageViewMinLodFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT,
ePhysicalDeviceShaderTileImageFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT, eImageViewMinLodCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT,
ePhysicalDeviceShaderTileImagePropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT, ePhysicalDeviceMultiDrawFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT,
eMicromapBuildInfoEXT = VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT, ePhysicalDeviceMultiDrawPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT,
eMicromapVersionInfoEXT = VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT, ePhysicalDeviceImage2DViewOf3DFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT,
eCopyMicromapInfoEXT = VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT, ePhysicalDeviceShaderTileImageFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT,
eCopyMicromapToMemoryInfoEXT = VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT, ePhysicalDeviceShaderTileImagePropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT,
eCopyMemoryToMicromapInfoEXT = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT, eMicromapBuildInfoEXT = VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT,
ePhysicalDeviceOpacityMicromapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT, eMicromapVersionInfoEXT = VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT,
ePhysicalDeviceOpacityMicromapPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT, eCopyMicromapInfoEXT = VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT,
eMicromapCreateInfoEXT = VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT, eCopyMicromapToMemoryInfoEXT = VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT,
eMicromapBuildSizesInfoEXT = VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT, eCopyMemoryToMicromapInfoEXT = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT,
eAccelerationStructureTrianglesOpacityMicromapEXT = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT, ePhysicalDeviceOpacityMicromapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT,
ePhysicalDeviceOpacityMicromapPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT,
eMicromapCreateInfoEXT = VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT,
eMicromapBuildSizesInfoEXT = VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT,
eAccelerationStructureTrianglesOpacityMicromapEXT = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT,
#if defined( VK_ENABLE_BETA_EXTENSIONS ) #if defined( VK_ENABLE_BETA_EXTENSIONS )
ePhysicalDeviceDisplacementMicromapFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV, ePhysicalDeviceDisplacementMicromapFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV,
ePhysicalDeviceDisplacementMicromapPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV, ePhysicalDeviceDisplacementMicromapPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV,
@ -7963,6 +7967,76 @@ namespace VULKAN_HPP_NAMESPACE
}; };
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
//=== VK_VALVE_video_encode_rgb_conversion ===
// wrapper class for enum VkVideoEncodeRgbModelConversionFlagBitsVALVE, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbModelConversionFlagBitsVALVE.html
enum class VideoEncodeRgbModelConversionFlagBitsVALVE : VkVideoEncodeRgbModelConversionFlagsVALVE
{
eRgbIdentity = VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE,
eYcbcrIdentity = VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE,
eYcbcr709 = VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE,
eYcbcr601 = VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE,
eYcbcr2020 = VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE
};
// wrapper using for bitmask VkVideoEncodeRgbModelConversionFlagsVALVE, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbModelConversionFlagsVALVE.html
using VideoEncodeRgbModelConversionFlagsVALVE = Flags<VideoEncodeRgbModelConversionFlagBitsVALVE>;
template <>
struct FlagTraits<VideoEncodeRgbModelConversionFlagBitsVALVE>
{
using WrappedType = VkVideoEncodeRgbModelConversionFlagBitsVALVE;
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeRgbModelConversionFlagsVALVE allFlags =
VideoEncodeRgbModelConversionFlagBitsVALVE::eRgbIdentity | VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcrIdentity |
VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr709 | VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr601 |
VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr2020;
};
// wrapper class for enum VkVideoEncodeRgbRangeCompressionFlagBitsVALVE, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbRangeCompressionFlagBitsVALVE.html
enum class VideoEncodeRgbRangeCompressionFlagBitsVALVE : VkVideoEncodeRgbRangeCompressionFlagsVALVE
{
eFullRange = VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE,
eNarrowRange = VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE
};
// wrapper using for bitmask VkVideoEncodeRgbRangeCompressionFlagsVALVE, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbRangeCompressionFlagsVALVE.html
using VideoEncodeRgbRangeCompressionFlagsVALVE = Flags<VideoEncodeRgbRangeCompressionFlagBitsVALVE>;
template <>
struct FlagTraits<VideoEncodeRgbRangeCompressionFlagBitsVALVE>
{
using WrappedType = VkVideoEncodeRgbRangeCompressionFlagBitsVALVE;
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeRgbRangeCompressionFlagsVALVE allFlags =
VideoEncodeRgbRangeCompressionFlagBitsVALVE::eFullRange | VideoEncodeRgbRangeCompressionFlagBitsVALVE::eNarrowRange;
};
// wrapper class for enum VkVideoEncodeRgbChromaOffsetFlagBitsVALVE, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbChromaOffsetFlagBitsVALVE.html
enum class VideoEncodeRgbChromaOffsetFlagBitsVALVE : VkVideoEncodeRgbChromaOffsetFlagsVALVE
{
eCositedEven = VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE,
eMidpoint = VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE
};
// wrapper using for bitmask VkVideoEncodeRgbChromaOffsetFlagsVALVE, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbChromaOffsetFlagsVALVE.html
using VideoEncodeRgbChromaOffsetFlagsVALVE = Flags<VideoEncodeRgbChromaOffsetFlagBitsVALVE>;
template <>
struct FlagTraits<VideoEncodeRgbChromaOffsetFlagBitsVALVE>
{
using WrappedType = VkVideoEncodeRgbChromaOffsetFlagBitsVALVE;
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeRgbChromaOffsetFlagsVALVE allFlags =
VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven | VideoEncodeRgbChromaOffsetFlagBitsVALVE::eMidpoint;
};
//=== VK_EXT_opacity_micromap === //=== VK_EXT_opacity_micromap ===
// wrapper class for enum VkMicromapTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapTypeEXT.html // wrapper class for enum VkMicromapTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapTypeEXT.html

16
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -367,6 +367,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_ray_tracing_maintenance1", "VK_KHR_ray_tracing_maintenance1",
"VK_KHR_shader_untyped_pointers", "VK_KHR_shader_untyped_pointers",
"VK_EXT_global_priority_query", "VK_EXT_global_priority_query",
"VK_VALVE_video_encode_rgb_conversion",
"VK_EXT_image_view_min_lod", "VK_EXT_image_view_min_lod",
"VK_EXT_multi_draw", "VK_EXT_multi_draw",
"VK_EXT_image_2d_view_of_3d", "VK_EXT_image_2d_view_of_3d",
@ -2054,6 +2055,16 @@ namespace VULKAN_HPP_NAMESPACE
{ { { {
"VK_EXT_global_priority", "VK_EXT_global_priority",
} } } } }, } } } } },
{ "VK_VALVE_video_encode_rgb_conversion",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_sampler_ycbcr_conversion",
"VK_KHR_video_encode_queue",
} } },
{ "VK_VERSION_1_1",
{ {
"VK_KHR_video_encode_queue",
} } } } },
{ "VK_EXT_image_view_min_lod", { "VK_EXT_image_view_min_lod",
{ { "VK_VERSION_1_0", { { "VK_VERSION_1_0",
{ { { {
@ -3599,8 +3610,9 @@ namespace VULKAN_HPP_NAMESPACE
( extension == "VK_EXT_multisampled_render_to_single_sampled" ) || ( extension == "VK_EXT_extended_dynamic_state2" ) || ( extension == "VK_EXT_multisampled_render_to_single_sampled" ) || ( extension == "VK_EXT_extended_dynamic_state2" ) ||
( extension == "VK_EXT_color_write_enable" ) || ( extension == "VK_EXT_primitives_generated_query" ) || ( extension == "VK_EXT_color_write_enable" ) || ( extension == "VK_EXT_primitives_generated_query" ) ||
( extension == "VK_KHR_ray_tracing_maintenance1" ) || ( extension == "VK_KHR_shader_untyped_pointers" ) || ( extension == "VK_KHR_ray_tracing_maintenance1" ) || ( extension == "VK_KHR_shader_untyped_pointers" ) ||
( extension == "VK_EXT_global_priority_query" ) || ( extension == "VK_EXT_image_view_min_lod" ) || ( extension == "VK_EXT_multi_draw" ) || ( extension == "VK_EXT_global_priority_query" ) || ( extension == "VK_VALVE_video_encode_rgb_conversion" ) ||
( extension == "VK_EXT_image_2d_view_of_3d" ) || ( extension == "VK_EXT_shader_tile_image" ) || ( extension == "VK_EXT_opacity_micromap" ) ( extension == "VK_EXT_image_view_min_lod" ) || ( extension == "VK_EXT_multi_draw" ) || ( extension == "VK_EXT_image_2d_view_of_3d" ) ||
( extension == "VK_EXT_shader_tile_image" ) || ( extension == "VK_EXT_opacity_micromap" )
#if defined( VK_ENABLE_BETA_EXTENSIONS ) #if defined( VK_ENABLE_BETA_EXTENSIONS )
|| ( extension == "VK_NV_displacement_micromap" ) || ( extension == "VK_NV_displacement_micromap" )
#endif /*VK_ENABLE_BETA_EXTENSIONS*/ #endif /*VK_ENABLE_BETA_EXTENSIONS*/

2
include/vulkan/vulkan_funcs.hpp
View file

@ -9,7 +9,7 @@
#define VULKAN_FUNCS_HPP #define VULKAN_FUNCS_HPP
// include-what-you-use: make sure, vulkan.hpp is used by code-completers // include-what-you-use: make sure, vulkan.hpp is used by code-completers
// IWYU pragma: private; include "vulkan.hpp" // IWYU pragma: private, include "vulkan/vulkan.hpp"
namespace VULKAN_HPP_NAMESPACE namespace VULKAN_HPP_NAMESPACE
{ {

8
include/vulkan/vulkan_handles.hpp
View file

@ -9,7 +9,7 @@
#define VULKAN_HANDLES_HPP #define VULKAN_HANDLES_HPP
// include-what-you-use: make sure, vulkan.hpp is used by code-completers // include-what-you-use: make sure, vulkan.hpp is used by code-completers
// IWYU pragma: private; include "vulkan.hpp" // IWYU pragma: private, include "vulkan/vulkan.hpp"
namespace VULKAN_HPP_NAMESPACE namespace VULKAN_HPP_NAMESPACE
{ {
@ -1545,6 +1545,12 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_KHR_shader_untyped_pointers === //=== VK_KHR_shader_untyped_pointers ===
struct PhysicalDeviceShaderUntypedPointersFeaturesKHR; struct PhysicalDeviceShaderUntypedPointersFeaturesKHR;
//=== VK_VALVE_video_encode_rgb_conversion ===
struct PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE;
struct VideoEncodeRgbConversionCapabilitiesVALVE;
struct VideoEncodeProfileRgbConversionInfoVALVE;
struct VideoEncodeSessionRgbConversionCreateInfoVALVE;
//=== VK_EXT_image_view_min_lod === //=== VK_EXT_image_view_min_lod ===
struct PhysicalDeviceImageViewMinLodFeaturesEXT; struct PhysicalDeviceImageViewMinLodFeaturesEXT;
struct ImageViewMinLodCreateInfoEXT; struct ImageViewMinLodCreateInfoEXT;

63
include/vulkan/vulkan_hash.hpp
View file

@ -14436,6 +14436,21 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const & physicalDeviceVideoEncodeRgbConversionFeaturesVALVE ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeRgbConversionFeaturesVALVE.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeRgbConversionFeaturesVALVE.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeRgbConversionFeaturesVALVE.videoEncodeRgbConversion );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR>
{ {
@ -19637,6 +19652,20 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeProfileRgbConversionInfoVALVE>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::VideoEncodeProfileRgbConversionInfoVALVE const & videoEncodeProfileRgbConversionInfoVALVE ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeProfileRgbConversionInfoVALVE.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeProfileRgbConversionInfoVALVE.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeProfileRgbConversionInfoVALVE.performEncodeRgbConversion );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR> struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR>
{ {
@ -19740,6 +19769,23 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRgbConversionCapabilitiesVALVE>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRgbConversionCapabilitiesVALVE const & videoEncodeRgbConversionCapabilitiesVALVE ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.rgbModels );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.rgbRanges );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.xChromaOffsets );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.yChromaOffsets );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeSessionIntraRefreshCreateInfoKHR> struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeSessionIntraRefreshCreateInfoKHR>
{ {
@ -19782,6 +19828,23 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeSessionRgbConversionCreateInfoVALVE>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionRgbConversionCreateInfoVALVE const & videoEncodeSessionRgbConversionCreateInfoVALVE ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.rgbModel );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.rgbRange );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.xChromaOffset );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.yChromaOffset );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR> struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR>
{ {

24
include/vulkan/vulkan_raii.hpp
View file

@ -6023,6 +6023,18 @@ namespace VULKAN_HPP_NAMESPACE
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html
VULKAN_HPP_NODISCARD MemoryRequirements getMemoryRequirements() const VULKAN_HPP_NOEXCEPT; VULKAN_HPP_NODISCARD MemoryRequirements getMemoryRequirements() const VULKAN_HPP_NOEXCEPT;
protected:
Buffer( VULKAN_HPP_NAMESPACE::Device device,
VULKAN_HPP_NAMESPACE::Buffer buffer,
const AllocationCallbacks * allocator,
detail::DeviceDispatcher const * dispatcher ) VULKAN_HPP_NOEXCEPT
: m_device( exchange( device, {} ) )
, m_buffer( exchange( buffer, {} ) )
, m_allocator( exchange( allocator, {} ) )
, m_dispatcher( exchange( dispatcher, nullptr ) )
{
}
private: private:
VULKAN_HPP_NAMESPACE::Device m_device = {}; VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::Buffer m_buffer = {}; VULKAN_HPP_NAMESPACE::Buffer m_buffer = {};
@ -10681,6 +10693,18 @@ namespace VULKAN_HPP_NAMESPACE
template <typename X, typename Y, typename... Z> template <typename X, typename Y, typename... Z>
VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getSubresourceLayout2KHR( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getSubresourceLayout2KHR( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT;
protected:
Image( VULKAN_HPP_NAMESPACE::Device device,
VULKAN_HPP_NAMESPACE::Image image,
const AllocationCallbacks * allocator,
detail::DeviceDispatcher const * dispatcher ) VULKAN_HPP_NOEXCEPT
: m_device( exchange( device, {} ) )
, m_image( exchange( image, {} ) )
, m_allocator( exchange( allocator, {} ) )
, m_dispatcher( exchange( dispatcher, nullptr ) )
{
}
private: private:
VULKAN_HPP_NAMESPACE::Device m_device = {}; VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::Image m_image = {}; VULKAN_HPP_NAMESPACE::Image m_image = {};

32
include/vulkan/vulkan_static_assertions.hpp
View file

@ -6216,6 +6216,38 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUntypedPointersFeaturesKHR>::value, VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUntypedPointersFeaturesKHR>::value,
"PhysicalDeviceShaderUntypedPointersFeaturesKHR is not nothrow_move_constructible!" ); "PhysicalDeviceShaderUntypedPointersFeaturesKHR is not nothrow_move_constructible!" );
//=== VK_VALVE_video_encode_rgb_conversion ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE ) ==
sizeof( VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE>::value,
"PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeRgbConversionCapabilitiesVALVE ) == sizeof( VkVideoEncodeRgbConversionCapabilitiesVALVE ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeRgbConversionCapabilitiesVALVE>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeRgbConversionCapabilitiesVALVE>::value,
"VideoEncodeRgbConversionCapabilitiesVALVE is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeProfileRgbConversionInfoVALVE ) == sizeof( VkVideoEncodeProfileRgbConversionInfoVALVE ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeProfileRgbConversionInfoVALVE>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeProfileRgbConversionInfoVALVE>::value,
"VideoEncodeProfileRgbConversionInfoVALVE is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeSessionRgbConversionCreateInfoVALVE ) ==
sizeof( VkVideoEncodeSessionRgbConversionCreateInfoVALVE ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeSessionRgbConversionCreateInfoVALVE>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeSessionRgbConversionCreateInfoVALVE>::value,
"VideoEncodeSessionRgbConversionCreateInfoVALVE is not nothrow_move_constructible!" );
//=== VK_EXT_image_view_min_lod === //=== VK_EXT_image_view_min_lod ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT ) == sizeof( VkPhysicalDeviceImageViewMinLodFeaturesEXT ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT ) == sizeof( VkPhysicalDeviceImageViewMinLodFeaturesEXT ),

10658
include/vulkan/vulkan_structs.hpp
View file

File diff suppressed because it is too large Load diff

136
include/vulkan/vulkan_to_string.hpp
View file

@ -3612,6 +3612,59 @@ namespace VULKAN_HPP_NAMESPACE
} }
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
//=== VK_VALVE_video_encode_rgb_conversion ===
VULKAN_HPP_INLINE std::string to_string( VideoEncodeRgbModelConversionFlagsVALVE value )
{
std::string result = "{";
if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eRgbIdentity )
result += " RgbIdentity |";
if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcrIdentity )
result += " YcbcrIdentity |";
if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr709 )
result += " Ycbcr709 |";
if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr601 )
result += " Ycbcr601 |";
if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr2020 )
result += " Ycbcr2020 |";
if ( result.size() > 1 )
result.back() = '}';
else
result = "{}";
return result;
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeRgbRangeCompressionFlagsVALVE value )
{
std::string result = "{";
if ( value & VideoEncodeRgbRangeCompressionFlagBitsVALVE::eFullRange )
result += " FullRange |";
if ( value & VideoEncodeRgbRangeCompressionFlagBitsVALVE::eNarrowRange )
result += " NarrowRange |";
if ( result.size() > 1 )
result.back() = '}';
else
result = "{}";
return result;
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeRgbChromaOffsetFlagsVALVE value )
{
std::string result = "{";
if ( value & VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven )
result += " CositedEven |";
if ( value & VideoEncodeRgbChromaOffsetFlagBitsVALVE::eMidpoint )
result += " Midpoint |";
if ( result.size() > 1 )
result.back() = '}';
else
result = "{}";
return result;
}
//=== VK_EXT_opacity_micromap === //=== VK_EXT_opacity_micromap ===
VULKAN_HPP_INLINE std::string to_string( BuildMicromapFlagsEXT value ) VULKAN_HPP_INLINE std::string to_string( BuildMicromapFlagsEXT value )
@ -5005,28 +5058,32 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_USE_PLATFORM_SCREEN_QNX ) #if defined( VK_USE_PLATFORM_SCREEN_QNX )
case StructureType::eScreenSurfaceCreateInfoQNX: return "ScreenSurfaceCreateInfoQNX"; case StructureType::eScreenSurfaceCreateInfoQNX: return "ScreenSurfaceCreateInfoQNX";
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
case StructureType::ePhysicalDeviceColorWriteEnableFeaturesEXT : return "PhysicalDeviceColorWriteEnableFeaturesEXT"; case StructureType::ePhysicalDeviceColorWriteEnableFeaturesEXT : return "PhysicalDeviceColorWriteEnableFeaturesEXT";
case StructureType::ePipelineColorWriteCreateInfoEXT : return "PipelineColorWriteCreateInfoEXT"; case StructureType::ePipelineColorWriteCreateInfoEXT : return "PipelineColorWriteCreateInfoEXT";
case StructureType::ePhysicalDevicePrimitivesGeneratedQueryFeaturesEXT: return "PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT"; case StructureType::ePhysicalDevicePrimitivesGeneratedQueryFeaturesEXT : return "PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT";
case StructureType::ePhysicalDeviceRayTracingMaintenance1FeaturesKHR : return "PhysicalDeviceRayTracingMaintenance1FeaturesKHR"; case StructureType::ePhysicalDeviceRayTracingMaintenance1FeaturesKHR : return "PhysicalDeviceRayTracingMaintenance1FeaturesKHR";
case StructureType::ePhysicalDeviceShaderUntypedPointersFeaturesKHR : return "PhysicalDeviceShaderUntypedPointersFeaturesKHR"; case StructureType::ePhysicalDeviceShaderUntypedPointersFeaturesKHR : return "PhysicalDeviceShaderUntypedPointersFeaturesKHR";
case StructureType::ePhysicalDeviceImageViewMinLodFeaturesEXT : return "PhysicalDeviceImageViewMinLodFeaturesEXT"; case StructureType::ePhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE: return "PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE";
case StructureType::eImageViewMinLodCreateInfoEXT : return "ImageViewMinLodCreateInfoEXT"; case StructureType::eVideoEncodeRgbConversionCapabilitiesVALVE : return "VideoEncodeRgbConversionCapabilitiesVALVE";
case StructureType::ePhysicalDeviceMultiDrawFeaturesEXT : return "PhysicalDeviceMultiDrawFeaturesEXT"; case StructureType::eVideoEncodeProfileRgbConversionInfoVALVE : return "VideoEncodeProfileRgbConversionInfoVALVE";
case StructureType::ePhysicalDeviceMultiDrawPropertiesEXT : return "PhysicalDeviceMultiDrawPropertiesEXT"; case StructureType::eVideoEncodeSessionRgbConversionCreateInfoVALVE : return "VideoEncodeSessionRgbConversionCreateInfoVALVE";
case StructureType::ePhysicalDeviceImage2DViewOf3DFeaturesEXT : return "PhysicalDeviceImage2DViewOf3DFeaturesEXT"; case StructureType::ePhysicalDeviceImageViewMinLodFeaturesEXT : return "PhysicalDeviceImageViewMinLodFeaturesEXT";
case StructureType::ePhysicalDeviceShaderTileImageFeaturesEXT : return "PhysicalDeviceShaderTileImageFeaturesEXT"; case StructureType::eImageViewMinLodCreateInfoEXT : return "ImageViewMinLodCreateInfoEXT";
case StructureType::ePhysicalDeviceShaderTileImagePropertiesEXT : return "PhysicalDeviceShaderTileImagePropertiesEXT"; case StructureType::ePhysicalDeviceMultiDrawFeaturesEXT : return "PhysicalDeviceMultiDrawFeaturesEXT";
case StructureType::eMicromapBuildInfoEXT : return "MicromapBuildInfoEXT"; case StructureType::ePhysicalDeviceMultiDrawPropertiesEXT : return "PhysicalDeviceMultiDrawPropertiesEXT";
case StructureType::eMicromapVersionInfoEXT : return "MicromapVersionInfoEXT"; case StructureType::ePhysicalDeviceImage2DViewOf3DFeaturesEXT : return "PhysicalDeviceImage2DViewOf3DFeaturesEXT";
case StructureType::eCopyMicromapInfoEXT : return "CopyMicromapInfoEXT"; case StructureType::ePhysicalDeviceShaderTileImageFeaturesEXT : return "PhysicalDeviceShaderTileImageFeaturesEXT";
case StructureType::eCopyMicromapToMemoryInfoEXT : return "CopyMicromapToMemoryInfoEXT"; case StructureType::ePhysicalDeviceShaderTileImagePropertiesEXT : return "PhysicalDeviceShaderTileImagePropertiesEXT";
case StructureType::eCopyMemoryToMicromapInfoEXT : return "CopyMemoryToMicromapInfoEXT"; case StructureType::eMicromapBuildInfoEXT : return "MicromapBuildInfoEXT";
case StructureType::ePhysicalDeviceOpacityMicromapFeaturesEXT : return "PhysicalDeviceOpacityMicromapFeaturesEXT"; case StructureType::eMicromapVersionInfoEXT : return "MicromapVersionInfoEXT";
case StructureType::ePhysicalDeviceOpacityMicromapPropertiesEXT : return "PhysicalDeviceOpacityMicromapPropertiesEXT"; case StructureType::eCopyMicromapInfoEXT : return "CopyMicromapInfoEXT";
case StructureType::eMicromapCreateInfoEXT : return "MicromapCreateInfoEXT"; case StructureType::eCopyMicromapToMemoryInfoEXT : return "CopyMicromapToMemoryInfoEXT";
case StructureType::eMicromapBuildSizesInfoEXT : return "MicromapBuildSizesInfoEXT"; case StructureType::eCopyMemoryToMicromapInfoEXT : return "CopyMemoryToMicromapInfoEXT";
case StructureType::eAccelerationStructureTrianglesOpacityMicromapEXT : return "AccelerationStructureTrianglesOpacityMicromapEXT"; case StructureType::ePhysicalDeviceOpacityMicromapFeaturesEXT : return "PhysicalDeviceOpacityMicromapFeaturesEXT";
case StructureType::ePhysicalDeviceOpacityMicromapPropertiesEXT : return "PhysicalDeviceOpacityMicromapPropertiesEXT";
case StructureType::eMicromapCreateInfoEXT : return "MicromapCreateInfoEXT";
case StructureType::eMicromapBuildSizesInfoEXT : return "MicromapBuildSizesInfoEXT";
case StructureType::eAccelerationStructureTrianglesOpacityMicromapEXT : return "AccelerationStructureTrianglesOpacityMicromapEXT";
#if defined( VK_ENABLE_BETA_EXTENSIONS ) #if defined( VK_ENABLE_BETA_EXTENSIONS )
case StructureType::ePhysicalDeviceDisplacementMicromapFeaturesNV : return "PhysicalDeviceDisplacementMicromapFeaturesNV"; case StructureType::ePhysicalDeviceDisplacementMicromapFeaturesNV : return "PhysicalDeviceDisplacementMicromapFeaturesNV";
case StructureType::ePhysicalDeviceDisplacementMicromapPropertiesNV : return "PhysicalDeviceDisplacementMicromapPropertiesNV"; case StructureType::ePhysicalDeviceDisplacementMicromapPropertiesNV : return "PhysicalDeviceDisplacementMicromapPropertiesNV";
@ -9575,6 +9632,41 @@ namespace VULKAN_HPP_NAMESPACE
} }
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
//=== VK_VALVE_video_encode_rgb_conversion ===
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRgbModelConversionFlagBitsVALVE value )
{
switch ( value )
{
case VideoEncodeRgbModelConversionFlagBitsVALVE::eRgbIdentity : return "RgbIdentity";
case VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcrIdentity: return "YcbcrIdentity";
case VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr709 : return "Ycbcr709";
case VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr601 : return "Ycbcr601";
case VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr2020 : return "Ycbcr2020";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRgbRangeCompressionFlagBitsVALVE value )
{
switch ( value )
{
case VideoEncodeRgbRangeCompressionFlagBitsVALVE::eFullRange : return "FullRange";
case VideoEncodeRgbRangeCompressionFlagBitsVALVE::eNarrowRange: return "NarrowRange";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRgbChromaOffsetFlagBitsVALVE value )
{
switch ( value )
{
case VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven: return "CositedEven";
case VideoEncodeRgbChromaOffsetFlagBitsVALVE::eMidpoint : return "Midpoint";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
//=== VK_EXT_opacity_micromap === //=== VK_EXT_opacity_micromap ===
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MicromapTypeEXT value ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MicromapTypeEXT value )

27
registry/base_generator.py
View file

@ -65,18 +65,25 @@ def externSyncGet(elem):
def getQueues(elem) -> Queues: def getQueues(elem) -> Queues:
queuemap = {
'VK_QUEUE_COMPUTE_BIT': Queues.COMPUTE,
'VK_QUEUE_DATA_GRAPH_BIT_ARM': Queues.DATA_GRAPH,
'VK_QUEUE_GRAPHICS_BIT': Queues.GRAPHICS,
'VK_QUEUE_OPTICAL_FLOW_BIT_NV': Queues.OPTICAL_FLOW,
'VK_QUEUE_PROTECTED_BIT': Queues.PROTECTED,
'VK_QUEUE_SPARSE_BINDING_BIT': Queues.SPARSE_BINDING,
'VK_QUEUE_TRANSFER_BIT': Queues.TRANSFER,
'VK_QUEUE_VIDEO_DECODE_BIT_KHR': Queues.DECODE,
'VK_QUEUE_VIDEO_ENCODE_BIT_KHR': Queues.ENCODE,
}
queues = 0 queues = 0
queues_list = splitIfGet(elem, 'queues') queues_list = splitIfGet(elem, 'queues')
if len(queues_list) > 0:
queues |= Queues.TRANSFER if 'transfer' in queues_list else 0 for queue in queues_list:
queues |= Queues.GRAPHICS if 'graphics' in queues_list else 0 if queue in queuemap:
queues |= Queues.COMPUTE if 'compute' in queues_list else 0 queues |= queuemap[queue]
queues |= Queues.PROTECTED if 'protected' in queues_list else 0
queues |= Queues.SPARSE_BINDING if 'sparse_binding' in queues_list else 0
queues |= Queues.OPTICAL_FLOW if 'opticalflow' in queues_list else 0
queues |= Queues.DECODE if 'decode' in queues_list else 0
queues |= Queues.ENCODE if 'encode' in queues_list else 0
queues |= Queues.DATA_GRAPH if 'data_graph' in queues_list else 0
return queues return queues
# Shared object used by Sync elements that do not have ones # Shared object used by Sync elements that do not have ones

1112
registry/validusage.json
View file

File diff suppressed because one or more lines are too long

670
registry/vk.xml
View file

File diff suppressed because it is too large Load diff