kbz_8/MacroLibX
1
0
Fork 0
mirror of https://github.com/seekrs/MacroLibX.git synced 2026-04-25 16:21:26 +02:00
Code Issues Packages Projects Releases Wiki Activity

trying to fix merge conflicts

Browse Source
This commit is contained in:
kbz_8
2024-12-04 15:55:11 +01:00
parent 999ef64d0a e425b66591
commit 65fd92dca9
19 changed files with 17994 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/linux_clang.yml vendored
View File

@@ -35,7 +35,7 @@ jobs:
# Build the lib # Build the lib
- name: Build MacroLibX - name: Build MacroLibX
run: make -j && make fclean && make -j DEBUG=true run: make -j && make fclean && make debug
# Build the example # Build the example
- name: Build Example - name: Build Example

2
.github/workflows/linux_gcc.yml vendored
View File

@@ -35,7 +35,7 @@ jobs:
# Build the lib # Build the lib
- name: Build MacroLibX - name: Build MacroLibX
run: make TOOLCHAIN=gcc -j && make fclean && make TOOLCHAIN=gcc DEBUG=true -j run: make TOOLCHAIN=gcc -j && make fclean && make TOOLCHAIN=gcc debug
# Build the example # Build the example
- name: Build Example - name: Build Example

2
.github/workflows/macos_x86.yml vendored
View File

@@ -35,7 +35,7 @@ jobs:
# Build the lib # Build the lib
- name: Build MacroLibX - name: Build MacroLibX
run: make -j && make fclean && make DEBUG=true -j run: make -j && make fclean && make debug
# Build the example # Build the example
- name: Build Example - name: Build Example

1
Makefile
View File

@@ -168,6 +168,7 @@ clean:
fclean: clean fclean: clean
@$(RM) $(NAME) @$(RM) $(NAME)
@printf "Cleaned $(_BOLD)$(NAME)$(_RESET)\n" @printf "Cleaned $(_BOLD)$(NAME)$(_RESET)\n"
@printf "Cleaned $(_BOLD)$(NAME)$(_RESET)\n"
re: fclean _printbuildinfos re: fclean _printbuildinfos
@$(MAKE) $(NAME) @$(MAKE) $(NAME)

4
third_party/vk_video/vulkan_video_codec_av1std.h vendored
View File

@@ -132,7 +132,7 @@ typedef enum StdVideoAV1FrameRestorationType {
typedef enum StdVideoAV1ColorPrimaries { typedef enum StdVideoAV1ColorPrimaries {
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709 = 1, STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709 = 1,
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = 2, STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED = 2,
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M = 4, STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M = 4,
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G = 5, STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G = 5,
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601 = 6, STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601 = 6,
@@ -144,6 +144,8 @@ typedef enum StdVideoAV1ColorPrimaries {
STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432 = 12, STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432 = 12,
STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213 = 22, STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213 = 22,
STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID = 0x7FFFFFFF, STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID = 0x7FFFFFFF,
// STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED is a deprecated alias
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED,
STD_VIDEO_AV1_COLOR_PRIMARIES_MAX_ENUM = 0x7FFFFFFF STD_VIDEO_AV1_COLOR_PRIMARIES_MAX_ENUM = 0x7FFFFFFF
} StdVideoAV1ColorPrimaries; } StdVideoAV1ColorPrimaries;

143
third_party/vk_video/vulkan_video_codec_av1std_encode.h vendored git.filemode.normal_file
View File

@@ -0,0 +1,143 @@
#ifndef VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_
#define VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_ 1
/*
** Copyright 2015-2024 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/
/*
** This header is generated from the Khronos Vulkan XML API Registry.
**
*/
#ifdef __cplusplus
extern "C" {
#endif
// vulkan_video_codec_av1std_encode is a preprocessor guard. Do not pass it to API calls.
#define vulkan_video_codec_av1std_encode 1
#include "vulkan_video_codec_av1std.h"
#define VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0)
#define VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_API_VERSION_1_0_0
#define VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_av1_encode"
typedef struct StdVideoEncodeAV1DecoderModelInfo {
uint8_t buffer_delay_length_minus_1;
uint8_t buffer_removal_time_length_minus_1;
uint8_t frame_presentation_time_length_minus_1;
uint8_t reserved1;
uint32_t num_units_in_decoding_tick;
} StdVideoEncodeAV1DecoderModelInfo;
typedef struct StdVideoEncodeAV1ExtensionHeader {
uint8_t temporal_id;
uint8_t spatial_id;
} StdVideoEncodeAV1ExtensionHeader;
typedef struct StdVideoEncodeAV1OperatingPointInfoFlags {
uint32_t decoder_model_present_for_this_op : 1;
uint32_t low_delay_mode_flag : 1;
uint32_t initial_display_delay_present_for_this_op : 1;
uint32_t reserved : 29;
} StdVideoEncodeAV1OperatingPointInfoFlags;
typedef struct StdVideoEncodeAV1OperatingPointInfo {
StdVideoEncodeAV1OperatingPointInfoFlags flags;
uint16_t operating_point_idc;
uint8_t seq_level_idx;
uint8_t seq_tier;
uint32_t decoder_buffer_delay;
uint32_t encoder_buffer_delay;
uint8_t initial_display_delay_minus_1;
} StdVideoEncodeAV1OperatingPointInfo;
typedef struct StdVideoEncodeAV1PictureInfoFlags {
uint32_t error_resilient_mode : 1;
uint32_t disable_cdf_update : 1;
uint32_t use_superres : 1;
uint32_t render_and_frame_size_different : 1;
uint32_t allow_screen_content_tools : 1;
uint32_t is_filter_switchable : 1;
uint32_t force_integer_mv : 1;
uint32_t frame_size_override_flag : 1;
uint32_t buffer_removal_time_present_flag : 1;
uint32_t allow_intrabc : 1;
uint32_t frame_refs_short_signaling : 1;
uint32_t allow_high_precision_mv : 1;
uint32_t is_motion_mode_switchable : 1;
uint32_t use_ref_frame_mvs : 1;
uint32_t disable_frame_end_update_cdf : 1;
uint32_t allow_warped_motion : 1;
uint32_t reduced_tx_set : 1;
uint32_t skip_mode_present : 1;
uint32_t delta_q_present : 1;
uint32_t delta_lf_present : 1;
uint32_t delta_lf_multi : 1;
uint32_t segmentation_enabled : 1;
uint32_t segmentation_update_map : 1;
uint32_t segmentation_temporal_update : 1;
uint32_t segmentation_update_data : 1;
uint32_t UsesLr : 1;
uint32_t usesChromaLr : 1;
uint32_t show_frame : 1;
uint32_t showable_frame : 1;
uint32_t reserved : 3;
} StdVideoEncodeAV1PictureInfoFlags;
typedef struct StdVideoEncodeAV1PictureInfo {
StdVideoEncodeAV1PictureInfoFlags flags;
StdVideoAV1FrameType frame_type;
uint32_t frame_presentation_time;
uint32_t current_frame_id;
uint8_t order_hint;
uint8_t primary_ref_frame;
uint8_t refresh_frame_flags;
uint8_t coded_denom;
uint16_t render_width_minus_1;
uint16_t render_height_minus_1;
StdVideoAV1InterpolationFilter interpolation_filter;
StdVideoAV1TxMode TxMode;
uint8_t delta_q_res;
uint8_t delta_lf_res;
uint8_t ref_order_hint[STD_VIDEO_AV1_NUM_REF_FRAMES];
int8_t ref_frame_idx[STD_VIDEO_AV1_REFS_PER_FRAME];
uint8_t reserved1[3];
uint32_t delta_frame_id_minus_1[STD_VIDEO_AV1_REFS_PER_FRAME];
const StdVideoAV1TileInfo* pTileInfo;
const StdVideoAV1Quantization* pQuantization;
const StdVideoAV1Segmentation* pSegmentation;
const StdVideoAV1LoopFilter* pLoopFilter;
const StdVideoAV1CDEF* pCDEF;
const StdVideoAV1LoopRestoration* pLoopRestoration;
const StdVideoAV1GlobalMotion* pGlobalMotion;
const StdVideoEncodeAV1ExtensionHeader* pExtensionHeader;
const uint32_t* pBufferRemovalTimes;
} StdVideoEncodeAV1PictureInfo;
typedef struct StdVideoEncodeAV1ReferenceInfoFlags {
uint32_t disable_frame_end_update_cdf : 1;
uint32_t segmentation_enabled : 1;
uint32_t reserved : 30;
} StdVideoEncodeAV1ReferenceInfoFlags;
typedef struct StdVideoEncodeAV1ReferenceInfo {
StdVideoEncodeAV1ReferenceInfoFlags flags;
uint32_t RefFrameId;
StdVideoAV1FrameType frame_type;
uint8_t OrderHint;
uint8_t reserved1[3];
const StdVideoEncodeAV1ExtensionHeader* pExtensionHeader;
} StdVideoEncodeAV1ReferenceInfo;
#ifdef __cplusplus
}
#endif
#endif

75
third_party/vulkan/vulkan.cppm vendored
View File

@@ -872,6 +872,18 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::ScopeKHR; using VULKAN_HPP_NAMESPACE::ScopeKHR;
using VULKAN_HPP_NAMESPACE::ScopeNV; using VULKAN_HPP_NAMESPACE::ScopeNV;
//=== VK_KHR_video_encode_av1 ===
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilityFlagBitsKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilityFlagsKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1PredictionModeKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlFlagBitsKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlFlagsKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlGroupKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1StdFlagBitsKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1StdFlagsKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1SuperblockSizeFlagBitsKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1SuperblockSizeFlagsKHR;
//=== VK_QCOM_image_processing2 === //=== VK_QCOM_image_processing2 ===
using VULKAN_HPP_NAMESPACE::BlockMatchWindowCompareModeQCOM; using VULKAN_HPP_NAMESPACE::BlockMatchWindowCompareModeQCOM;
@@ -889,6 +901,12 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::TimeDomainEXT; using VULKAN_HPP_NAMESPACE::TimeDomainEXT;
using VULKAN_HPP_NAMESPACE::TimeDomainKHR; using VULKAN_HPP_NAMESPACE::TimeDomainKHR;
<<<<<<< HEAD
=======
//=== VK_NV_display_stereo ===
using VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoTypeNV;
>>>>>>> indev
//=== VK_KHR_maintenance7 === //=== VK_KHR_maintenance7 ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiKHR; using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiKHR;
@@ -2498,6 +2516,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::KHRVideoDecodeAv1SpecVersion; using VULKAN_HPP_NAMESPACE::KHRVideoDecodeAv1SpecVersion;
using VULKAN_HPP_NAMESPACE::MaxVideoAv1ReferencesPerFrameKHR; using VULKAN_HPP_NAMESPACE::MaxVideoAv1ReferencesPerFrameKHR;
//=== VK_KHR_video_encode_av1 ===
using VULKAN_HPP_NAMESPACE::KHRVideoEncodeAv1ExtensionName;
using VULKAN_HPP_NAMESPACE::KHRVideoEncodeAv1SpecVersion;
//=== VK_KHR_video_maintenance1 === //=== VK_KHR_video_maintenance1 ===
using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance1ExtensionName; using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance1ExtensionName;
using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance1SpecVersion; using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance1SpecVersion;
@@ -2572,6 +2594,14 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationExtensionName; using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationExtensionName;
using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationSpecVersion; using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationSpecVersion;
//=== VK_NV_display_stereo ===
using VULKAN_HPP_NAMESPACE::NVDisplayStereoExtensionName;
using VULKAN_HPP_NAMESPACE::NVDisplayStereoSpecVersion;
//=== VK_KHR_video_encode_quantization_map ===
using VULKAN_HPP_NAMESPACE::KHRVideoEncodeQuantizationMapExtensionName;
using VULKAN_HPP_NAMESPACE::KHRVideoEncodeQuantizationMapSpecVersion;
//=== VK_NV_raw_access_chains === //=== VK_NV_raw_access_chains ===
using VULKAN_HPP_NAMESPACE::NVRawAccessChainsExtensionName; using VULKAN_HPP_NAMESPACE::NVRawAccessChainsExtensionName;
using VULKAN_HPP_NAMESPACE::NVRawAccessChainsSpecVersion; using VULKAN_HPP_NAMESPACE::NVRawAccessChainsSpecVersion;
@@ -2620,6 +2650,13 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::NVCooperativeMatrix2ExtensionName; using VULKAN_HPP_NAMESPACE::NVCooperativeMatrix2ExtensionName;
using VULKAN_HPP_NAMESPACE::NVCooperativeMatrix2SpecVersion; using VULKAN_HPP_NAMESPACE::NVCooperativeMatrix2SpecVersion;
<<<<<<< HEAD
=======
//=== VK_EXT_vertex_attribute_robustness ===
using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessExtensionName;
using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessSpecVersion;
>>>>>>> indev
//======================== //========================
//=== CONSTEXPR VALUEs === //=== CONSTEXPR VALUEs ===
//======================== //========================
@@ -3209,6 +3246,7 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX; using VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX;
using VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX; using VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX;
using VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX; using VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX;
using VULKAN_HPP_NAMESPACE::CuModuleTexturingModeCreateInfoNVX;
//=== VK_NVX_image_view_handle === //=== VK_NVX_image_view_handle ===
using VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX; using VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX;
@@ -4400,6 +4438,21 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR; using VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR;
using VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR; using VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR;
//=== VK_KHR_video_encode_av1 ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeAV1FeaturesKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilitiesKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1DpbSlotInfoKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1FrameSizeKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1GopRemainingFrameInfoKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1PictureInfoKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1ProfileInfoKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1QIndexKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1QualityLevelPropertiesKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlInfoKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlLayerInfoKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionCreateInfoKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionParametersCreateInfoKHR;
//=== VK_KHR_video_maintenance1 === //=== VK_KHR_video_maintenance1 ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR; using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR;
using VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR; using VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR;
@@ -4484,6 +4537,22 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_descriptor_pool_overallocation === //=== VK_NV_descriptor_pool_overallocation ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV; using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
//=== VK_NV_display_stereo ===
using VULKAN_HPP_NAMESPACE::DisplayModeStereoPropertiesNV;
using VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV;
//=== VK_KHR_video_encode_quantization_map ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1QuantizationMapCapabilitiesKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeH264QuantizationMapCapabilitiesKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeH265QuantizationMapCapabilitiesKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapCapabilitiesKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapInfoKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapSessionParametersCreateInfoKHR;
using VULKAN_HPP_NAMESPACE::VideoFormatAV1QuantizationMapPropertiesKHR;
using VULKAN_HPP_NAMESPACE::VideoFormatH265QuantizationMapPropertiesKHR;
using VULKAN_HPP_NAMESPACE::VideoFormatQuantizationMapPropertiesKHR;
//=== VK_NV_raw_access_chains === //=== VK_NV_raw_access_chains ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV; using VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV;
@@ -4553,6 +4622,12 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV; using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV; using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV;
<<<<<<< HEAD
=======
//=== VK_EXT_vertex_attribute_robustness ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT;
>>>>>>> indev
//=============== //===============
//=== HANDLEs === //=== HANDLEs ===
//=============== //===============

8423
third_party/vulkan/vulkan.hpp vendored
View File

File diff suppressed because it is too large Load Diff

710
third_party/vulkan/vulkan_core.h vendored
View File

File diff suppressed because it is too large Load Diff

563
third_party/vulkan/vulkan_enums.hpp vendored
View File

File diff suppressed because it is too large Load Diff

92
third_party/vulkan/vulkan_extension_inspection.hpp vendored
View File

@@ -8,6 +8,15 @@
#ifndef VULKAN_EXTENSION_INSPECTION_HPP #ifndef VULKAN_EXTENSION_INSPECTION_HPP
#define VULKAN_EXTENSION_INSPECTION_HPP #define VULKAN_EXTENSION_INSPECTION_HPP
#if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE )
import VULKAN_HPP_STD_MODULE;
#else
# include <map>
# include <set>
# include <string>
# include <vector>
# include <vulkan/vulkan.hpp>
#endif
#if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) #if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE )
import VULKAN_HPP_STD_MODULE; import VULKAN_HPP_STD_MODULE;
#else #else
@@ -46,7 +55,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_INLINE std::map<std::string, std::string> const & getDeprecatedExtensions() VULKAN_HPP_INLINE std::map<std::string, std::string> const & getDeprecatedExtensions()
{ {
static std::map<std::string, std::string> deprecatedExtensions = { static const std::map<std::string, std::string> deprecatedExtensions = {
{ "VK_EXT_debug_report", "VK_EXT_debug_utils" }, { "VK_EXT_debug_report", "VK_EXT_debug_utils" },
{ "VK_NV_glsl_shader", "" }, { "VK_NV_glsl_shader", "" },
{ "VK_NV_dedicated_allocation", "VK_KHR_dedicated_allocation" }, { "VK_NV_dedicated_allocation", "VK_KHR_dedicated_allocation" },
@@ -68,6 +77,7 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_USE_PLATFORM_MACOS_MVK*/ #endif /*VK_USE_PLATFORM_MACOS_MVK*/
{ "VK_AMD_gpu_shader_int16", "VK_KHR_shader_float16_int8" }, { "VK_AMD_gpu_shader_int16", "VK_KHR_shader_float16_int8" },
{ "VK_NV_ray_tracing", "VK_KHR_ray_tracing_pipeline" }, { "VK_NV_ray_tracing", "VK_KHR_ray_tracing_pipeline" },
{ "VK_NV_ray_tracing", "VK_KHR_ray_tracing_pipeline" },
{ "VK_EXT_buffer_device_address", "VK_KHR_buffer_device_address" }, { "VK_EXT_buffer_device_address", "VK_KHR_buffer_device_address" },
{ "VK_EXT_validation_features", "VK_EXT_layer_settings" } { "VK_EXT_validation_features", "VK_EXT_layer_settings" }
}; };
@@ -76,7 +86,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_INLINE std::set<std::string> const & getDeviceExtensions() VULKAN_HPP_INLINE std::set<std::string> const & getDeviceExtensions()
{ {
static std::set<std::string> deviceExtensions = { static const std::set<std::string> deviceExtensions = {
"VK_KHR_swapchain", "VK_KHR_swapchain",
"VK_KHR_display_swapchain", "VK_KHR_display_swapchain",
"VK_NV_glsl_shader", "VK_NV_glsl_shader",
@@ -347,6 +357,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_EXT_primitive_topology_list_restart", "VK_EXT_primitive_topology_list_restart",
"VK_KHR_format_feature_flags2", "VK_KHR_format_feature_flags2",
"VK_EXT_present_mode_fifo_latest_ready", "VK_EXT_present_mode_fifo_latest_ready",
"VK_EXT_present_mode_fifo_latest_ready",
#if defined( VK_USE_PLATFORM_FUCHSIA ) #if defined( VK_USE_PLATFORM_FUCHSIA )
"VK_FUCHSIA_external_memory", "VK_FUCHSIA_external_memory",
"VK_FUCHSIA_external_semaphore", "VK_FUCHSIA_external_semaphore",
@@ -406,9 +417,11 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
"VK_KHR_maintenance5", "VK_KHR_maintenance5",
"VK_AMD_anti_lag", "VK_AMD_anti_lag",
"VK_AMD_anti_lag",
"VK_KHR_ray_tracing_position_fetch", "VK_KHR_ray_tracing_position_fetch",
"VK_EXT_shader_object", "VK_EXT_shader_object",
"VK_KHR_pipeline_binary", "VK_KHR_pipeline_binary",
"VK_KHR_pipeline_binary",
"VK_QCOM_tile_properties", "VK_QCOM_tile_properties",
"VK_SEC_amigo_profiling", "VK_SEC_amigo_profiling",
"VK_QCOM_multiview_per_view_viewports", "VK_QCOM_multiview_per_view_viewports",
@@ -416,6 +429,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_NV_extended_sparse_address_space", "VK_NV_extended_sparse_address_space",
"VK_EXT_mutable_descriptor_type", "VK_EXT_mutable_descriptor_type",
"VK_EXT_legacy_vertex_attributes", "VK_EXT_legacy_vertex_attributes",
"VK_EXT_legacy_vertex_attributes",
"VK_ARM_shader_core_builtins", "VK_ARM_shader_core_builtins",
"VK_EXT_pipeline_library_group_handles", "VK_EXT_pipeline_library_group_handles",
"VK_EXT_dynamic_rendering_unused_attachments", "VK_EXT_dynamic_rendering_unused_attachments",
@@ -423,7 +437,9 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_cooperative_matrix", "VK_KHR_cooperative_matrix",
"VK_QCOM_multiview_per_view_render_areas", "VK_QCOM_multiview_per_view_render_areas",
"VK_KHR_compute_shader_derivatives", "VK_KHR_compute_shader_derivatives",
"VK_KHR_compute_shader_derivatives",
"VK_KHR_video_decode_av1", "VK_KHR_video_decode_av1",
"VK_KHR_video_encode_av1",
"VK_KHR_video_maintenance1", "VK_KHR_video_maintenance1",
"VK_NV_per_stage_descriptor_set", "VK_NV_per_stage_descriptor_set",
"VK_QCOM_image_processing2", "VK_QCOM_image_processing2",
@@ -444,10 +460,14 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_shader_expect_assume", "VK_KHR_shader_expect_assume",
"VK_KHR_maintenance6", "VK_KHR_maintenance6",
"VK_NV_descriptor_pool_overallocation", "VK_NV_descriptor_pool_overallocation",
"VK_KHR_video_encode_quantization_map",
"VK_NV_raw_access_chains", "VK_NV_raw_access_chains",
"VK_KHR_shader_relaxed_extended_instruction", "VK_KHR_shader_relaxed_extended_instruction",
"VK_NV_command_buffer_inheritance", "VK_NV_command_buffer_inheritance",
"VK_KHR_maintenance7", "VK_KHR_maintenance7",
"VK_KHR_shader_relaxed_extended_instruction",
"VK_NV_command_buffer_inheritance",
"VK_KHR_maintenance7",
"VK_NV_shader_atomic_float16_vector", "VK_NV_shader_atomic_float16_vector",
"VK_EXT_shader_replicated_composites", "VK_EXT_shader_replicated_composites",
"VK_NV_ray_tracing_validation", "VK_NV_ray_tracing_validation",
@@ -462,7 +482,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_INLINE std::set<std::string> const & getInstanceExtensions() VULKAN_HPP_INLINE std::set<std::string> const & getInstanceExtensions()
{ {
static std::set<std::string> instanceExtensions = { static const std::set<std::string> instanceExtensions = {
"VK_KHR_surface", "VK_KHR_surface",
"VK_KHR_display", "VK_KHR_display",
#if defined( VK_USE_PLATFORM_XLIB_KHR ) #if defined( VK_USE_PLATFORM_XLIB_KHR )
@@ -529,15 +549,16 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_portability_enumeration", "VK_KHR_portability_enumeration",
"VK_GOOGLE_surfaceless_query", "VK_GOOGLE_surfaceless_query",
"VK_LUNARG_direct_driver_loading", "VK_LUNARG_direct_driver_loading",
"VK_EXT_layer_settings" "VK_EXT_layer_settings",
"VK_NV_display_stereo"
}; };
return instanceExtensions; return instanceExtensions;
} }
VULKAN_HPP_INLINE std::map<std::string, std::vector<std::vector<std::string>>> const & getExtensionDepends( std::string const & extension ) VULKAN_HPP_INLINE std::map<std::string, std::vector<std::vector<std::string>>> const & getExtensionDepends( std::string const & extension )
{ {
static std::map<std::string, std::vector<std::vector<std::string>>> noDependencies; static const std::map<std::string, std::vector<std::vector<std::string>>> noDependencies;
static std::map<std::string, std::map<std::string, std::vector<std::vector<std::string>>>> dependencies = { static const std::map<std::string, std::map<std::string, std::vector<std::vector<std::string>>>> dependencies = {
{ "VK_KHR_swapchain", { "VK_KHR_swapchain",
{ { "VK_VERSION_1_0", { { "VK_VERSION_1_0",
{ { { {
@@ -999,9 +1020,12 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_synchronization2", "VK_KHR_synchronization2",
"VK_KHR_spirv_1_4", "VK_KHR_spirv_1_4",
"VK_EXT_extended_dynamic_state", "VK_EXT_extended_dynamic_state",
"VK_KHR_spirv_1_4",
"VK_EXT_extended_dynamic_state",
} } }, } } },
{ "VK_VERSION_1_3", { "VK_VERSION_1_3",
{ { { {
"VK_KHR_maintenance5",
"VK_KHR_maintenance5", "VK_KHR_maintenance5",
"VK_KHR_pipeline_library", "VK_KHR_pipeline_library",
} } } } }, } } } } },
@@ -1833,6 +1857,11 @@ namespace VULKAN_HPP_NAMESPACE
{ { { {
"VK_KHR_swapchain", "VK_KHR_swapchain",
} } } } }, } } } } },
{ "VK_EXT_present_mode_fifo_latest_ready",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_swapchain",
} } } } },
#if defined( VK_USE_PLATFORM_FUCHSIA ) #if defined( VK_USE_PLATFORM_FUCHSIA )
{ "VK_FUCHSIA_external_memory", { "VK_FUCHSIA_external_memory",
{ { "VK_VERSION_1_0", { { "VK_VERSION_1_0",
@@ -2172,6 +2201,11 @@ namespace VULKAN_HPP_NAMESPACE
{ { { {
"VK_KHR_maintenance5", "VK_KHR_maintenance5",
} } } } }, } } } } },
{ "VK_KHR_pipeline_binary",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_maintenance5",
} } } } },
{ "VK_QCOM_tile_properties", { "VK_QCOM_tile_properties",
{ { "VK_VERSION_1_0", { { "VK_VERSION_1_0",
{ { { {
@@ -2205,6 +2239,11 @@ namespace VULKAN_HPP_NAMESPACE
{ { { {
"VK_EXT_vertex_input_dynamic_state", "VK_EXT_vertex_input_dynamic_state",
} } } } }, } } } } },
{ "VK_EXT_legacy_vertex_attributes",
{ { "VK_VERSION_1_0",
{ {
"VK_EXT_vertex_input_dynamic_state",
} } } } },
{ "VK_ARM_shader_core_builtins", { "VK_ARM_shader_core_builtins",
{ { "VK_VERSION_1_0", { { "VK_VERSION_1_0",
{ { { {
@@ -2244,11 +2283,21 @@ namespace VULKAN_HPP_NAMESPACE
{ { { {
"VK_KHR_get_physical_device_properties2", "VK_KHR_get_physical_device_properties2",
} } } } }, } } } } },
{ "VK_KHR_compute_shader_derivatives",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } } } },
{ "VK_KHR_video_decode_av1", { "VK_KHR_video_decode_av1",
{ { "VK_VERSION_1_0", { { "VK_VERSION_1_0",
{ { { {
"VK_KHR_video_decode_queue", "VK_KHR_video_decode_queue",
} } } } }, } } } } },
{ "VK_KHR_video_encode_av1",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_video_encode_queue",
} } } } },
{ "VK_KHR_video_maintenance1", { "VK_KHR_video_maintenance1",
{ { "VK_VERSION_1_0", { { "VK_VERSION_1_0",
{ { { {
@@ -2414,13 +2463,13 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_INLINE std::map<std::string, std::string> const & getObsoletedExtensions() VULKAN_HPP_INLINE std::map<std::string, std::string> const & getObsoletedExtensions()
{ {
static std::map<std::string, std::string> obsoletedExtensions = { { "VK_AMD_negative_viewport_height", "VK_KHR_maintenance1" } }; static const std::map<std::string, std::string> obsoletedExtensions = { { "VK_AMD_negative_viewport_height", "VK_KHR_maintenance1" } };
return obsoletedExtensions; return obsoletedExtensions;
} }
VULKAN_HPP_INLINE std::map<std::string, std::string> const & getPromotedExtensions() VULKAN_HPP_INLINE std::map<std::string, std::string> const & getPromotedExtensions()
{ {
static std::map<std::string, std::string> promotedExtensions = { static const std::map<std::string, std::string> promotedExtensions = {
{ "VK_KHR_sampler_mirror_clamp_to_edge", "VK_VERSION_1_2" }, { "VK_KHR_sampler_mirror_clamp_to_edge", "VK_VERSION_1_2" },
{ "VK_EXT_debug_marker", "VK_EXT_debug_utils" }, { "VK_EXT_debug_marker", "VK_EXT_debug_utils" },
{ "VK_AMD_draw_indirect_count", "VK_KHR_draw_indirect_count" }, { "VK_AMD_draw_indirect_count", "VK_KHR_draw_indirect_count" },
@@ -2472,6 +2521,7 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_KHR_shader_float_controls", "VK_VERSION_1_2" }, { "VK_KHR_shader_float_controls", "VK_VERSION_1_2" },
{ "VK_KHR_depth_stencil_resolve", "VK_VERSION_1_2" }, { "VK_KHR_depth_stencil_resolve", "VK_VERSION_1_2" },
{ "VK_NV_compute_shader_derivatives", "VK_KHR_compute_shader_derivatives" }, { "VK_NV_compute_shader_derivatives", "VK_KHR_compute_shader_derivatives" },
{ "VK_NV_compute_shader_derivatives", "VK_KHR_compute_shader_derivatives" },
{ "VK_NV_fragment_shader_barycentric", "VK_KHR_fragment_shader_barycentric" }, { "VK_NV_fragment_shader_barycentric", "VK_KHR_fragment_shader_barycentric" },
{ "VK_KHR_timeline_semaphore", "VK_VERSION_1_2" }, { "VK_KHR_timeline_semaphore", "VK_VERSION_1_2" },
{ "VK_KHR_vulkan_memory_model", "VK_VERSION_1_2" }, { "VK_KHR_vulkan_memory_model", "VK_VERSION_1_2" },
@@ -2579,6 +2629,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
return "VK_KHR_ray_tracing_pipeline"; return "VK_KHR_ray_tracing_pipeline";
} }
if ( extension == "VK_NV_ray_tracing" )
{
return "VK_KHR_ray_tracing_pipeline";
}
if ( extension == "VK_EXT_buffer_device_address" ) if ( extension == "VK_EXT_buffer_device_address" )
{ {
return "VK_KHR_buffer_device_address"; return "VK_KHR_buffer_device_address";
@@ -2799,6 +2853,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
return "VK_KHR_compute_shader_derivatives"; return "VK_KHR_compute_shader_derivatives";
} }
if ( extension == "VK_NV_compute_shader_derivatives" )
{
return "VK_KHR_compute_shader_derivatives";
}
if ( extension == "VK_NV_fragment_shader_barycentric" ) if ( extension == "VK_NV_fragment_shader_barycentric" )
{ {
return "VK_KHR_fragment_shader_barycentric"; return "VK_KHR_fragment_shader_barycentric";
@@ -2959,6 +3017,8 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_USE_PLATFORM_MACOS_MVK*/ #endif /*VK_USE_PLATFORM_MACOS_MVK*/
( extension == "VK_AMD_gpu_shader_int16" ) || ( extension == "VK_NV_ray_tracing" ) || ( extension == "VK_EXT_buffer_device_address" ) || ( extension == "VK_AMD_gpu_shader_int16" ) || ( extension == "VK_NV_ray_tracing" ) || ( extension == "VK_EXT_buffer_device_address" ) ||
( extension == "VK_EXT_validation_features" ); ( extension == "VK_EXT_validation_features" );
( extension == "VK_AMD_gpu_shader_int16" ) || ( extension == "VK_NV_ray_tracing" ) || ( extension == "VK_EXT_buffer_device_address" ) ||
( extension == "VK_EXT_validation_features" );
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & extension ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & extension )
@@ -3103,6 +3163,7 @@ namespace VULKAN_HPP_NAMESPACE
( extension == "VK_EXT_physical_device_drm" ) || ( extension == "VK_EXT_device_address_binding_report" ) || ( extension == "VK_EXT_physical_device_drm" ) || ( extension == "VK_EXT_device_address_binding_report" ) ||
( extension == "VK_EXT_depth_clip_control" ) || ( extension == "VK_EXT_primitive_topology_list_restart" ) || ( extension == "VK_EXT_depth_clip_control" ) || ( extension == "VK_EXT_primitive_topology_list_restart" ) ||
( extension == "VK_KHR_format_feature_flags2" ) || ( extension == "VK_EXT_present_mode_fifo_latest_ready" ) ( extension == "VK_KHR_format_feature_flags2" ) || ( extension == "VK_EXT_present_mode_fifo_latest_ready" )
( extension == "VK_KHR_format_feature_flags2" ) || ( extension == "VK_EXT_present_mode_fifo_latest_ready" )
#if defined( VK_USE_PLATFORM_FUCHSIA ) #if defined( VK_USE_PLATFORM_FUCHSIA )
|| ( extension == "VK_FUCHSIA_external_memory" ) || ( extension == "VK_FUCHSIA_external_semaphore" ) || ( extension == "VK_FUCHSIA_buffer_collection" ) || ( extension == "VK_FUCHSIA_external_memory" ) || ( extension == "VK_FUCHSIA_external_semaphore" ) || ( extension == "VK_FUCHSIA_buffer_collection" )
#endif /*VK_USE_PLATFORM_FUCHSIA*/ #endif /*VK_USE_PLATFORM_FUCHSIA*/
@@ -3133,6 +3194,9 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_USE_PLATFORM_ANDROID_KHR ) #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|| ( extension == "VK_ANDROID_external_format_resolve" ) || ( extension == "VK_ANDROID_external_format_resolve" )
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|| ( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_AMD_anti_lag" ) || ( extension == "VK_KHR_ray_tracing_position_fetch" ) ||
( extension == "VK_EXT_shader_object" ) || ( extension == "VK_KHR_pipeline_binary" ) || ( extension == "VK_QCOM_tile_properties" ) ||
( extension == "VK_SEC_amigo_profiling" ) || ( extension == "VK_QCOM_multiview_per_view_viewports" ) ||
|| ( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_AMD_anti_lag" ) || ( extension == "VK_KHR_ray_tracing_position_fetch" ) || || ( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_AMD_anti_lag" ) || ( extension == "VK_KHR_ray_tracing_position_fetch" ) ||
( extension == "VK_EXT_shader_object" ) || ( extension == "VK_KHR_pipeline_binary" ) || ( extension == "VK_QCOM_tile_properties" ) || ( extension == "VK_EXT_shader_object" ) || ( extension == "VK_KHR_pipeline_binary" ) || ( extension == "VK_QCOM_tile_properties" ) ||
( extension == "VK_SEC_amigo_profiling" ) || ( extension == "VK_QCOM_multiview_per_view_viewports" ) || ( extension == "VK_SEC_amigo_profiling" ) || ( extension == "VK_QCOM_multiview_per_view_viewports" ) ||
@@ -3216,7 +3280,7 @@ namespace VULKAN_HPP_NAMESPACE
|| ( extension == "VK_QNX_screen_surface" ) || ( extension == "VK_QNX_screen_surface" )
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|| ( extension == "VK_KHR_portability_enumeration" ) || ( extension == "VK_GOOGLE_surfaceless_query" ) || || ( extension == "VK_KHR_portability_enumeration" ) || ( extension == "VK_GOOGLE_surfaceless_query" ) ||
( extension == "VK_LUNARG_direct_driver_loading" ) || ( extension == "VK_EXT_layer_settings" ); ( extension == "VK_LUNARG_direct_driver_loading" ) || ( extension == "VK_EXT_layer_settings" ) || ( extension == "VK_NV_display_stereo" );
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isObsoletedExtension( std::string const & extension ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isObsoletedExtension( std::string const & extension )
@@ -3259,6 +3323,16 @@ namespace VULKAN_HPP_NAMESPACE
( extension == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) || ( extension == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) ||
( extension == "VK_KHR_shader_integer_dot_product" ) || ( extension == "VK_EXT_texel_buffer_alignment" ) || ( extension == "VK_KHR_shader_integer_dot_product" ) || ( extension == "VK_EXT_texel_buffer_alignment" ) ||
( extension == "VK_KHR_shader_non_semantic_info" ) || ( extension == "VK_EXT_private_data" ) || ( extension == "VK_KHR_shader_non_semantic_info" ) || ( extension == "VK_EXT_private_data" ) ||
( extension == "VK_NV_compute_shader_derivatives" ) || ( extension == "VK_NV_fragment_shader_barycentric" ) ||
( extension == "VK_KHR_timeline_semaphore" ) || ( extension == "VK_KHR_vulkan_memory_model" ) ||
( extension == "VK_KHR_shader_terminate_invocation" ) || ( extension == "VK_EXT_scalar_block_layout" ) ||
( extension == "VK_EXT_subgroup_size_control" ) || ( extension == "VK_KHR_spirv_1_4" ) || ( extension == "VK_KHR_separate_depth_stencil_layouts" ) ||
( extension == "VK_EXT_tooling_info" ) || ( extension == "VK_EXT_separate_stencil_usage" ) ||
( extension == "VK_KHR_uniform_buffer_standard_layout" ) || ( extension == "VK_KHR_buffer_device_address" ) ||
( extension == "VK_EXT_line_rasterization" ) || ( extension == "VK_EXT_host_query_reset" ) || ( extension == "VK_EXT_index_type_uint8" ) ||
( extension == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) ||
( extension == "VK_KHR_shader_integer_dot_product" ) || ( extension == "VK_EXT_texel_buffer_alignment" ) ||
( extension == "VK_KHR_shader_non_semantic_info" ) || ( extension == "VK_EXT_private_data" ) ||
( extension == "VK_EXT_pipeline_creation_cache_control" ) || ( extension == "VK_KHR_synchronization2" ) || ( extension == "VK_EXT_pipeline_creation_cache_control" ) || ( extension == "VK_KHR_synchronization2" ) ||
( extension == "VK_KHR_zero_initialize_workgroup_memory" ) || ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) || ( extension == "VK_KHR_zero_initialize_workgroup_memory" ) || ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) ||
( extension == "VK_EXT_image_robustness" ) || ( extension == "VK_KHR_copy_commands2" ) || ( extension == "VK_EXT_4444_formats" ) || ( extension == "VK_EXT_image_robustness" ) || ( extension == "VK_KHR_copy_commands2" ) || ( extension == "VK_EXT_4444_formats" ) ||

3768
third_party/vulkan/vulkan_funcs.hpp vendored
View File

File diff suppressed because it is too large Load Diff

76
third_party/vulkan/vulkan_handles.hpp vendored
View File

@@ -572,6 +572,7 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NVX_binary_import === //=== VK_NVX_binary_import ===
struct CuModuleCreateInfoNVX; struct CuModuleCreateInfoNVX;
struct CuModuleTexturingModeCreateInfoNVX;
struct CuFunctionCreateInfoNVX; struct CuFunctionCreateInfoNVX;
struct CuLaunchInfoNVX; struct CuLaunchInfoNVX;
@@ -1765,6 +1766,21 @@ namespace VULKAN_HPP_NAMESPACE
struct VideoDecodeAV1PictureInfoKHR; struct VideoDecodeAV1PictureInfoKHR;
struct VideoDecodeAV1DpbSlotInfoKHR; struct VideoDecodeAV1DpbSlotInfoKHR;
//=== VK_KHR_video_encode_av1 ===
struct PhysicalDeviceVideoEncodeAV1FeaturesKHR;
struct VideoEncodeAV1CapabilitiesKHR;
struct VideoEncodeAV1QualityLevelPropertiesKHR;
struct VideoEncodeAV1SessionCreateInfoKHR;
struct VideoEncodeAV1SessionParametersCreateInfoKHR;
struct VideoEncodeAV1PictureInfoKHR;
struct VideoEncodeAV1DpbSlotInfoKHR;
struct VideoEncodeAV1ProfileInfoKHR;
struct VideoEncodeAV1QIndexKHR;
struct VideoEncodeAV1FrameSizeKHR;
struct VideoEncodeAV1GopRemainingFrameInfoKHR;
struct VideoEncodeAV1RateControlInfoKHR;
struct VideoEncodeAV1RateControlLayerInfoKHR;
//=== VK_KHR_video_maintenance1 === //=== VK_KHR_video_maintenance1 ===
struct PhysicalDeviceVideoMaintenance1FeaturesKHR; struct PhysicalDeviceVideoMaintenance1FeaturesKHR;
struct VideoInlineQueryInfoKHR; struct VideoInlineQueryInfoKHR;
@@ -1849,6 +1865,22 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_descriptor_pool_overallocation === //=== VK_NV_descriptor_pool_overallocation ===
struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV; struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
//=== VK_NV_display_stereo ===
struct DisplaySurfaceStereoCreateInfoNV;
struct DisplayModeStereoPropertiesNV;
//=== VK_KHR_video_encode_quantization_map ===
struct VideoEncodeQuantizationMapCapabilitiesKHR;
struct VideoFormatQuantizationMapPropertiesKHR;
struct VideoEncodeQuantizationMapInfoKHR;
struct VideoEncodeQuantizationMapSessionParametersCreateInfoKHR;
struct PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR;
struct VideoEncodeH264QuantizationMapCapabilitiesKHR;
struct VideoEncodeH265QuantizationMapCapabilitiesKHR;
struct VideoFormatH265QuantizationMapPropertiesKHR;
struct VideoEncodeAV1QuantizationMapCapabilitiesKHR;
struct VideoFormatAV1QuantizationMapPropertiesKHR;
//=== VK_NV_raw_access_chains === //=== VK_NV_raw_access_chains ===
struct PhysicalDeviceRawAccessChainsFeaturesNV; struct PhysicalDeviceRawAccessChainsFeaturesNV;
@@ -1918,6 +1950,12 @@ namespace VULKAN_HPP_NAMESPACE
struct PhysicalDeviceCooperativeMatrix2FeaturesNV; struct PhysicalDeviceCooperativeMatrix2FeaturesNV;
struct PhysicalDeviceCooperativeMatrix2PropertiesNV; struct PhysicalDeviceCooperativeMatrix2PropertiesNV;
<<<<<<< HEAD
=======
//=== VK_EXT_vertex_attribute_robustness ===
struct PhysicalDeviceVertexAttributeRobustnessFeaturesEXT;
>>>>>>> indev
//=================================== //===================================
//=== HANDLE forward declarations === //=== HANDLE forward declarations ===
//=================================== //===================================
@@ -12737,6 +12775,15 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
uint64_t getImageViewHandle64NVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
uint64_t getImageViewHandle64NVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NODISCARD Result getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView,
VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties, VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties,
@@ -16805,6 +16852,21 @@ namespace VULKAN_HPP_NAMESPACE
getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
VideoFormatPropertiesKHRAllocator & videoFormatPropertiesKHRAllocator, VideoFormatPropertiesKHRAllocator & videoFormatPropertiesKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename StructureChain,
typename StructureChainAllocator = std::allocator<StructureChain>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename StructureChain,
typename StructureChainAllocator = std::allocator<StructureChain>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
StructureChainAllocator & structureChainAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_NV_external_memory_capabilities === //=== VK_NV_external_memory_capabilities ===
@@ -17213,6 +17275,20 @@ namespace VULKAN_HPP_NAMESPACE
getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator, DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename StructureChain,
typename StructureChainAllocator = std::allocator<StructureChain>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename StructureChain,
typename StructureChainAllocator = std::allocator<StructureChain>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
StructureChainAllocator & structureChainAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

434
third_party/vulkan/vulkan_hash.hpp vendored
View File

@@ -2911,6 +2911,19 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::CuModuleTexturingModeCreateInfoNVX>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleTexturingModeCreateInfoNVX const & cuModuleTexturingModeCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, cuModuleTexturingModeCreateInfoNVX.sType );
VULKAN_HPP_HASH_COMBINE( seed, cuModuleTexturingModeCreateInfoNVX.pNext );
VULKAN_HPP_HASH_COMBINE( seed, cuModuleTexturingModeCreateInfoNVX.use64bitTexturing );
return seed;
}
};
# if defined( VK_ENABLE_BETA_EXTENSIONS ) # if defined( VK_ENABLE_BETA_EXTENSIONS )
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV> struct hash<VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV>
@@ -4304,6 +4317,19 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::DisplayModeStereoPropertiesNV>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeStereoPropertiesNV const & displayModeStereoPropertiesNV ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, displayModeStereoPropertiesNV.sType );
VULKAN_HPP_HASH_COMBINE( seed, displayModeStereoPropertiesNV.pNext );
VULKAN_HPP_HASH_COMBINE( seed, displayModeStereoPropertiesNV.hdmi3DSupported );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD> struct hash<VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD>
{ {
@@ -4470,6 +4496,19 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV const & displaySurfaceStereoCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceStereoCreateInfoNV.sType );
VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceStereoCreateInfoNV.pNext );
VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceStereoCreateInfoNV.stereoType );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand> struct hash<VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand>
{ {
@@ -12774,6 +12813,21 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT const & physicalDeviceVertexAttributeRobustnessFeaturesEXT ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeRobustnessFeaturesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeRobustnessFeaturesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeRobustnessFeaturesEXT.vertexAttributeRobustness );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT>
{ {
@@ -12788,6 +12842,20 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeAV1FeaturesKHR>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeAV1FeaturesKHR const & physicalDeviceVideoEncodeAV1FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeAV1FeaturesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeAV1FeaturesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeAV1FeaturesKHR.videoEncodeAV1 );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR> struct hash<VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR>
{ {
@@ -12819,6 +12887,21 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const & physicalDeviceVideoEncodeQuantizationMapFeaturesKHR ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQuantizationMapFeaturesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQuantizationMapFeaturesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQuantizationMapFeaturesKHR.videoEncodeQuantizationMap );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR>
{ {
@@ -16648,6 +16731,243 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilitiesKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilitiesKHR const & videoEncodeAV1CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.flags );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxLevel );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.codedPictureAlignment );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxTiles );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.minTileSize );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxTileSize );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.superblockSizes );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxSingleReferenceCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.singleReferenceNameMask );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxUnidirectionalCompoundReferenceCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxUnidirectionalCompoundGroup1ReferenceCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.unidirectionalCompoundReferenceNameMask );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxBidirectionalCompoundReferenceCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxBidirectionalCompoundGroup1ReferenceCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxBidirectionalCompoundGroup2ReferenceCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.bidirectionalCompoundReferenceNameMask );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxTemporalLayerCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxSpatialLayerCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxOperatingPoints );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.minQIndex );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxQIndex );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.prefersGopRemainingFrames );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.requiresGopRemainingFrames );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.stdSyntaxFlags );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1DpbSlotInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1DpbSlotInfoKHR const & videoEncodeAV1DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1DpbSlotInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1DpbSlotInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1DpbSlotInfoKHR.pStdReferenceInfo );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1FrameSizeKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1FrameSizeKHR const & videoEncodeAV1FrameSizeKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1FrameSizeKHR.intraFrameSize );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1FrameSizeKHR.predictiveFrameSize );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1FrameSizeKHR.bipredictiveFrameSize );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1GopRemainingFrameInfoKHR>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1GopRemainingFrameInfoKHR const & videoEncodeAV1GopRemainingFrameInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.useGopRemainingFrames );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.gopRemainingIntra );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.gopRemainingPredictive );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.gopRemainingBipredictive );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1PictureInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1PictureInfoKHR const & videoEncodeAV1PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.predictionMode );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.rateControlGroup );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.constantQIndex );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.pStdPictureInfo );
for ( size_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i )
{
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.referenceNameSlotIndices[i] );
}
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.primaryReferenceCdfOnly );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.generateObuExtensionHeader );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1ProfileInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1ProfileInfoKHR const & videoEncodeAV1ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1ProfileInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1ProfileInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1ProfileInfoKHR.stdProfile );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1QIndexKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QIndexKHR const & videoEncodeAV1QIndexKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QIndexKHR.intraQIndex );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QIndexKHR.predictiveQIndex );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QIndexKHR.bipredictiveQIndex );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1QualityLevelPropertiesKHR>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QualityLevelPropertiesKHR const & videoEncodeAV1QualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredRateControlFlags );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredGopFrameCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredKeyFramePeriod );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredConsecutiveBipredictiveFrameCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredTemporalLayerCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredConstantQIndex );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxSingleReferenceCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredSingleReferenceNameMask );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxUnidirectionalCompoundReferenceCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxUnidirectionalCompoundGroup1ReferenceCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredUnidirectionalCompoundReferenceNameMask );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxBidirectionalCompoundReferenceCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxBidirectionalCompoundGroup1ReferenceCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxBidirectionalCompoundGroup2ReferenceCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredBidirectionalCompoundReferenceNameMask );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1QuantizationMapCapabilitiesKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QuantizationMapCapabilitiesKHR const & videoEncodeAV1QuantizationMapCapabilitiesKHR ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QuantizationMapCapabilitiesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QuantizationMapCapabilitiesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QuantizationMapCapabilitiesKHR.minQIndexDelta );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QuantizationMapCapabilitiesKHR.maxQIndexDelta );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlInfoKHR const & videoEncodeAV1RateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.flags );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.gopFrameCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.keyFramePeriod );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.consecutiveBipredictiveFrameCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.temporalLayerCount );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlLayerInfoKHR>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlLayerInfoKHR const & videoEncodeAV1RateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.useMinQIndex );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.minQIndex );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.useMaxQIndex );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.maxQIndex );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.useMaxFrameSize );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.maxFrameSize );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionCreateInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionCreateInfoKHR const & videoEncodeAV1SessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionCreateInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionCreateInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionCreateInfoKHR.useMaxLevel );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionCreateInfoKHR.maxLevel );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionParametersCreateInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionParametersCreateInfoKHR const & videoEncodeAV1SessionParametersCreateInfoKHR ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.pStdSequenceHeader );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.pStdDecoderModelInfo );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.stdOperatingPointCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.pStdOperatingPoints );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR> struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR>
{ {
@@ -16813,6 +17133,21 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QuantizationMapCapabilitiesKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QuantizationMapCapabilitiesKHR const & videoEncodeH264QuantizationMapCapabilitiesKHR ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QuantizationMapCapabilitiesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QuantizationMapCapabilitiesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QuantizationMapCapabilitiesKHR.minQpDelta );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QuantizationMapCapabilitiesKHR.maxQpDelta );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoKHR> struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoKHR>
{ {
@@ -17076,6 +17411,21 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QuantizationMapCapabilitiesKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QuantizationMapCapabilitiesKHR const & videoEncodeH265QuantizationMapCapabilitiesKHR ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QuantizationMapCapabilitiesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QuantizationMapCapabilitiesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QuantizationMapCapabilitiesKHR.minQpDelta );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QuantizationMapCapabilitiesKHR.maxQpDelta );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoKHR> struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoKHR>
{ {
@@ -17245,6 +17595,48 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapCapabilitiesKHR>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapCapabilitiesKHR const & videoEncodeQuantizationMapCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapCapabilitiesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapCapabilitiesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapCapabilitiesKHR.maxQuantizationMapExtent );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapInfoKHR const & videoEncodeQuantizationMapInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapInfoKHR.quantizationMap );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapInfoKHR.quantizationMapExtent );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapSessionParametersCreateInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapSessionParametersCreateInfoKHR const &
videoEncodeQuantizationMapSessionParametersCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapSessionParametersCreateInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapSessionParametersCreateInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapSessionParametersCreateInfoKHR.quantizationMapTexelSize );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR> struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR>
{ {
@@ -17335,6 +17727,34 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoFormatAV1QuantizationMapPropertiesKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatAV1QuantizationMapPropertiesKHR const & videoFormatAV1QuantizationMapPropertiesKHR ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoFormatAV1QuantizationMapPropertiesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoFormatAV1QuantizationMapPropertiesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoFormatAV1QuantizationMapPropertiesKHR.compatibleSuperblockSizes );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoFormatH265QuantizationMapPropertiesKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatH265QuantizationMapPropertiesKHR const & videoFormatH265QuantizationMapPropertiesKHR ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoFormatH265QuantizationMapPropertiesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoFormatH265QuantizationMapPropertiesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoFormatH265QuantizationMapPropertiesKHR.compatibleCtbSizes );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> struct hash<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>
{ {
@@ -17353,6 +17773,20 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoFormatQuantizationMapPropertiesKHR>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::VideoFormatQuantizationMapPropertiesKHR const & videoFormatQuantizationMapPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoFormatQuantizationMapPropertiesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoFormatQuantizationMapPropertiesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoFormatQuantizationMapPropertiesKHR.quantizationMapTexelSize );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR> struct hash<VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR>
{ {

120
third_party/vulkan/vulkan_raii.hpp vendored
View File

@@ -926,8 +926,14 @@ namespace VULKAN_HPP_NAMESPACE
vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetDeviceProcAddr( device, "vkCmdCuLaunchKernelNVX" ) ); vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetDeviceProcAddr( device, "vkCmdCuLaunchKernelNVX" ) );
//=== VK_NVX_image_view_handle === //=== VK_NVX_image_view_handle ===
<<<<<<< HEAD
vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) ); vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) );
vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) ); vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) );
=======
vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) );
vkGetImageViewHandle64NVX = PFN_vkGetImageViewHandle64NVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandle64NVX" ) );
vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) );
>>>>>>> indev
//=== VK_AMD_draw_indirect_count === //=== VK_AMD_draw_indirect_count ===
vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) ); vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) );
@@ -1999,8 +2005,14 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0; PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0;
//=== VK_NVX_image_view_handle === //=== VK_NVX_image_view_handle ===
<<<<<<< HEAD
PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0; PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0;
PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0; PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0;
=======
PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0;
PFN_vkGetImageViewHandle64NVX vkGetImageViewHandle64NVX = 0;
PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0;
>>>>>>> indev
//=== VK_AMD_draw_indirect_count === //=== VK_AMD_draw_indirect_count ===
PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0; PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0;
@@ -3381,6 +3393,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>
getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const; getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const;
template <typename StructureChain>
VULKAN_HPP_NODISCARD std::vector<StructureChain>
getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const;
//=== VK_NV_external_memory_capabilities === //=== VK_NV_external_memory_capabilities ===
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV getExternalImageFormatPropertiesNV( VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV getExternalImageFormatPropertiesNV(
@@ -4046,6 +4062,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NODISCARD uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT; VULKAN_HPP_NODISCARD uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT;
VULKAN_HPP_NODISCARD uint64_t getImageViewHandle64NVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT;
//=== VK_KHR_device_group === //=== VK_KHR_device_group ===
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags
@@ -8224,6 +8242,9 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> getModeProperties2() const; VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> getModeProperties2() const;
template <typename StructureChain>
VULKAN_HPP_NODISCARD std::vector<StructureChain> getModeProperties2() const;
# if defined( VK_USE_PLATFORM_WIN32_KHR ) # if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_NV_acquire_winrt_display === //=== VK_NV_acquire_winrt_display ===
@@ -16397,6 +16418,52 @@ namespace VULKAN_HPP_NAMESPACE
return videoFormatProperties; return videoFormatProperties;
} }
template <typename StructureChain>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain>
PhysicalDevice::getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR &&
"Function <vkGetPhysicalDeviceVideoFormatPropertiesKHR> requires <VK_KHR_video_queue>" );
std::vector<StructureChain> structureChains;
std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> videoFormatProperties;
uint32_t videoFormatPropertyCount;
VULKAN_HPP_NAMESPACE::Result result;
do
{
result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
&videoFormatPropertyCount,
nullptr ) );
if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && videoFormatPropertyCount )
{
structureChains.resize( videoFormatPropertyCount );
videoFormatProperties.resize( videoFormatPropertyCount );
for ( uint32_t i = 0; i < videoFormatPropertyCount; i++ )
{
videoFormatProperties[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>().pNext;
}
result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
&videoFormatPropertyCount,
reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) ) );
}
} while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" );
VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() );
if ( videoFormatPropertyCount < videoFormatProperties.size() )
{
structureChains.resize( videoFormatPropertyCount );
}
for ( uint32_t i = 0; i < videoFormatPropertyCount; i++ )
{
structureChains[i].template get<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>() = videoFormatProperties[i];
}
return structureChains;
}
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR>::Type VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR>::Type
Device::createVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo, Device::createVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo,
@@ -16718,6 +16785,17 @@ namespace VULKAN_HPP_NAMESPACE
return result; return result;
} }
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t
Device::getImageViewHandle64NVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewHandle64NVX && "Function <vkGetImageViewHandle64NVX> requires <VK_NVX_image_view_handle>" );
uint64_t result =
getDispatcher()->vkGetImageViewHandle64NVX( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageViewHandleInfoNVX *>( &info ) );
return result;
}
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX ImageView::getAddressNVX() const VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX ImageView::getAddressNVX() const
{ {
VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewAddressNVX && "Function <vkGetImageViewAddressNVX> requires <VK_NVX_image_view_handle>" ); VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewAddressNVX && "Function <vkGetImageViewAddressNVX> requires <VK_NVX_image_view_handle>" );
@@ -18135,6 +18213,48 @@ namespace VULKAN_HPP_NAMESPACE
return properties; return properties;
} }
template <typename StructureChain>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain> DisplayKHR::getModeProperties2() const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayModeProperties2KHR &&
"Function <vkGetDisplayModeProperties2KHR> requires <VK_KHR_get_display_properties2>" );
std::vector<StructureChain> structureChains;
std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> properties;
uint32_t propertyCount;
VULKAN_HPP_NAMESPACE::Result result;
do
{
result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayModeProperties2KHR(
static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ), &propertyCount, nullptr ) );
if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
{
structureChains.resize( propertyCount );
properties.resize( propertyCount );
for ( uint32_t i = 0; i < propertyCount; i++ )
{
properties[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>().pNext;
}
result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
getDispatcher()->vkGetDisplayModeProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
static_cast<VkDisplayKHR>( m_display ),
&propertyCount,
reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) ) );
}
} while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::getModeProperties2" );
VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
if ( propertyCount < properties.size() )
{
structureChains.resize( propertyCount );
}
for ( uint32_t i = 0; i < propertyCount; i++ )
{
structureChains[i].template get<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>() = properties[i];
}
return structureChains;
}
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR
PhysicalDevice::getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo ) const PhysicalDevice::getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo ) const
{ {

198
third_party/vulkan/vulkan_static_assertions.hpp vendored
View File

@@ -2236,6 +2236,13 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::CuModule
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX>::value, VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX>::value,
"CuModuleCreateInfoNVX is not nothrow_move_constructible!" ); "CuModuleCreateInfoNVX is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuModuleTexturingModeCreateInfoNVX ) == sizeof( VkCuModuleTexturingModeCreateInfoNVX ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::CuModuleTexturingModeCreateInfoNVX>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CuModuleTexturingModeCreateInfoNVX>::value,
"CuModuleTexturingModeCreateInfoNVX is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX ) == sizeof( VkCuFunctionCreateInfoNVX ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX ) == sizeof( VkCuFunctionCreateInfoNVX ),
"struct and wrapper have different size!" ); "struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX>::value, "struct wrapper is not a standard layout!" ); VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX>::value, "struct wrapper is not a standard layout!" );
@@ -7356,6 +7363,93 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDec
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR>::value, VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR>::value,
"VideoDecodeAV1DpbSlotInfoKHR is not nothrow_move_constructible!" ); "VideoDecodeAV1DpbSlotInfoKHR is not nothrow_move_constructible!" );
//=== VK_KHR_video_encode_av1 ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeAV1FeaturesKHR ) == sizeof( VkPhysicalDeviceVideoEncodeAV1FeaturesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeAV1FeaturesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeAV1FeaturesKHR>::value,
"PhysicalDeviceVideoEncodeAV1FeaturesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilitiesKHR ) == sizeof( VkVideoEncodeAV1CapabilitiesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilitiesKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilitiesKHR>::value,
"VideoEncodeAV1CapabilitiesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QualityLevelPropertiesKHR ) == sizeof( VkVideoEncodeAV1QualityLevelPropertiesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeAV1QualityLevelPropertiesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeAV1QualityLevelPropertiesKHR>::value,
"VideoEncodeAV1QualityLevelPropertiesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionCreateInfoKHR ) == sizeof( VkVideoEncodeAV1SessionCreateInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionCreateInfoKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionCreateInfoKHR>::value,
"VideoEncodeAV1SessionCreateInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionParametersCreateInfoKHR ) ==
sizeof( VkVideoEncodeAV1SessionParametersCreateInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionParametersCreateInfoKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionParametersCreateInfoKHR>::value,
"VideoEncodeAV1SessionParametersCreateInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1PictureInfoKHR ) == sizeof( VkVideoEncodeAV1PictureInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeAV1PictureInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeAV1PictureInfoKHR>::value,
"VideoEncodeAV1PictureInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1DpbSlotInfoKHR ) == sizeof( VkVideoEncodeAV1DpbSlotInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeAV1DpbSlotInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeAV1DpbSlotInfoKHR>::value,
"VideoEncodeAV1DpbSlotInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1ProfileInfoKHR ) == sizeof( VkVideoEncodeAV1ProfileInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeAV1ProfileInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeAV1ProfileInfoKHR>::value,
"VideoEncodeAV1ProfileInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QIndexKHR ) == sizeof( VkVideoEncodeAV1QIndexKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeAV1QIndexKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeAV1QIndexKHR>::value,
"VideoEncodeAV1QIndexKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1FrameSizeKHR ) == sizeof( VkVideoEncodeAV1FrameSizeKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeAV1FrameSizeKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeAV1FrameSizeKHR>::value,
"VideoEncodeAV1FrameSizeKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1GopRemainingFrameInfoKHR ) == sizeof( VkVideoEncodeAV1GopRemainingFrameInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeAV1GopRemainingFrameInfoKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeAV1GopRemainingFrameInfoKHR>::value,
"VideoEncodeAV1GopRemainingFrameInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlInfoKHR ) == sizeof( VkVideoEncodeAV1RateControlInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlInfoKHR>::value,
"VideoEncodeAV1RateControlInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlLayerInfoKHR ) == sizeof( VkVideoEncodeAV1RateControlLayerInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlLayerInfoKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlLayerInfoKHR>::value,
"VideoEncodeAV1RateControlLayerInfoKHR is not nothrow_move_constructible!" );
//=== VK_KHR_video_maintenance1 === //=== VK_KHR_video_maintenance1 ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR ) == sizeof( VkPhysicalDeviceVideoMaintenance1FeaturesKHR ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR ) == sizeof( VkPhysicalDeviceVideoMaintenance1FeaturesKHR ),
@@ -7670,6 +7764,97 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV>::value, VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV>::value,
"PhysicalDeviceDescriptorPoolOverallocationFeaturesNV is not nothrow_move_constructible!" ); "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV is not nothrow_move_constructible!" );
//=== VK_NV_display_stereo ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV ) == sizeof( VkDisplaySurfaceStereoCreateInfoNV ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV>::value,
"DisplaySurfaceStereoCreateInfoNV is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeStereoPropertiesNV ) == sizeof( VkDisplayModeStereoPropertiesNV ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DisplayModeStereoPropertiesNV>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayModeStereoPropertiesNV>::value,
"DisplayModeStereoPropertiesNV is not nothrow_move_constructible!" );
//=== VK_KHR_video_encode_quantization_map ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapCapabilitiesKHR ) == sizeof( VkVideoEncodeQuantizationMapCapabilitiesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapCapabilitiesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapCapabilitiesKHR>::value,
"VideoEncodeQuantizationMapCapabilitiesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoFormatQuantizationMapPropertiesKHR ) == sizeof( VkVideoFormatQuantizationMapPropertiesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoFormatQuantizationMapPropertiesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoFormatQuantizationMapPropertiesKHR>::value,
"VideoFormatQuantizationMapPropertiesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapInfoKHR ) == sizeof( VkVideoEncodeQuantizationMapInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapInfoKHR>::value,
"VideoEncodeQuantizationMapInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapSessionParametersCreateInfoKHR ) ==
sizeof( VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapSessionParametersCreateInfoKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapSessionParametersCreateInfoKHR>::value,
"VideoEncodeQuantizationMapSessionParametersCreateInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR ) ==
sizeof( VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR>::value,
"PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264QuantizationMapCapabilitiesKHR ) ==
sizeof( VkVideoEncodeH264QuantizationMapCapabilitiesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeH264QuantizationMapCapabilitiesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeH264QuantizationMapCapabilitiesKHR>::value,
"VideoEncodeH264QuantizationMapCapabilitiesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265QuantizationMapCapabilitiesKHR ) ==
sizeof( VkVideoEncodeH265QuantizationMapCapabilitiesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeH265QuantizationMapCapabilitiesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeH265QuantizationMapCapabilitiesKHR>::value,
"VideoEncodeH265QuantizationMapCapabilitiesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoFormatH265QuantizationMapPropertiesKHR ) ==
sizeof( VkVideoFormatH265QuantizationMapPropertiesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoFormatH265QuantizationMapPropertiesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoFormatH265QuantizationMapPropertiesKHR>::value,
"VideoFormatH265QuantizationMapPropertiesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QuantizationMapCapabilitiesKHR ) ==
sizeof( VkVideoEncodeAV1QuantizationMapCapabilitiesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeAV1QuantizationMapCapabilitiesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeAV1QuantizationMapCapabilitiesKHR>::value,
"VideoEncodeAV1QuantizationMapCapabilitiesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoFormatAV1QuantizationMapPropertiesKHR ) == sizeof( VkVideoFormatAV1QuantizationMapPropertiesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoFormatAV1QuantizationMapPropertiesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoFormatAV1QuantizationMapPropertiesKHR>::value,
"VideoFormatAV1QuantizationMapPropertiesKHR is not nothrow_move_constructible!" );
//=== VK_NV_raw_access_chains === //=== VK_NV_raw_access_chains ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV ) == sizeof( VkPhysicalDeviceRawAccessChainsFeaturesNV ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV ) == sizeof( VkPhysicalDeviceRawAccessChainsFeaturesNV ),
@@ -8024,4 +8209,17 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV>::value, VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV>::value,
"PhysicalDeviceCooperativeMatrix2PropertiesNV is not nothrow_move_constructible!" ); "PhysicalDeviceCooperativeMatrix2PropertiesNV is not nothrow_move_constructible!" );
<<<<<<< HEAD
=======
//=== VK_EXT_vertex_attribute_robustness ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT ) ==
sizeof( VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT>::value,
"PhysicalDeviceVertexAttributeRobustnessFeaturesEXT is not nothrow_move_constructible!" );
>>>>>>> indev
#endif #endif

3079
third_party/vulkan/vulkan_structs.hpp vendored
View File

File diff suppressed because it is too large Load Diff

269
third_party/vulkan/vulkan_to_string.hpp vendored
View File

@@ -208,6 +208,10 @@ namespace VULKAN_HPP_NAMESPACE
result += "SampleWeightQCOM | "; result += "SampleWeightQCOM | ";
if ( value & ImageUsageFlagBits::eSampleBlockMatchQCOM ) if ( value & ImageUsageFlagBits::eSampleBlockMatchQCOM )
result += "SampleBlockMatchQCOM | "; result += "SampleBlockMatchQCOM | ";
if ( value & ImageUsageFlagBits::eVideoEncodeQuantizationDeltaMapKHR )
result += "VideoEncodeQuantizationDeltaMapKHR | ";
if ( value & ImageUsageFlagBits::eVideoEncodeEmphasisMapKHR )
result += "VideoEncodeEmphasisMapKHR | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
@@ -1860,6 +1864,10 @@ namespace VULKAN_HPP_NAMESPACE
result += "OpticalFlowVectorNV | "; result += "OpticalFlowVectorNV | ";
if ( value & FormatFeatureFlagBits2::eOpticalFlowCostNV ) if ( value & FormatFeatureFlagBits2::eOpticalFlowCostNV )
result += "OpticalFlowCostNV | "; result += "OpticalFlowCostNV | ";
if ( value & FormatFeatureFlagBits2::eVideoEncodeQuantizationDeltaMapKHR )
result += "VideoEncodeQuantizationDeltaMapKHR | ";
if ( value & FormatFeatureFlagBits2::eVideoEncodeEmphasisMapKHR )
result += "VideoEncodeEmphasisMapKHR | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
@@ -2065,6 +2073,8 @@ namespace VULKAN_HPP_NAMESPACE
result += "DecodeH265 | "; result += "DecodeH265 | ";
if ( value & VideoCodecOperationFlagBitsKHR::eDecodeAv1 ) if ( value & VideoCodecOperationFlagBitsKHR::eDecodeAv1 )
result += "DecodeAv1 | "; result += "DecodeAv1 | ";
if ( value & VideoCodecOperationFlagBitsKHR::eEncodeAv1 )
result += "EncodeAv1 | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
@@ -2129,13 +2139,24 @@ namespace VULKAN_HPP_NAMESPACE
result += "AllowEncodeParameterOptimizations | "; result += "AllowEncodeParameterOptimizations | ";
if ( value & VideoSessionCreateFlagBitsKHR::eInlineQueries ) if ( value & VideoSessionCreateFlagBitsKHR::eInlineQueries )
result += "InlineQueries | "; result += "InlineQueries | ";
if ( value & VideoSessionCreateFlagBitsKHR::eAllowEncodeQuantizationDeltaMap )
result += "AllowEncodeQuantizationDeltaMap | ";
if ( value & VideoSessionCreateFlagBitsKHR::eAllowEncodeEmphasisMap )
result += "AllowEncodeEmphasisMap | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
VULKAN_HPP_INLINE std::string to_string( VideoSessionParametersCreateFlagsKHR ) VULKAN_HPP_INLINE std::string to_string( VideoSessionParametersCreateFlagsKHR value )
{ {
if ( !value )
return "{}"; return "{}";
std::string result;
if ( value & VideoSessionParametersCreateFlagBitsKHR::eQuantizationMapCompatible )
result += "QuantizationMapCompatible | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
VULKAN_HPP_INLINE std::string to_string( VideoBeginCodingFlagsKHR ) VULKAN_HPP_INLINE std::string to_string( VideoBeginCodingFlagsKHR )
@@ -2234,6 +2255,8 @@ namespace VULKAN_HPP_NAMESPACE
result += "PerSliceConstantQp | "; result += "PerSliceConstantQp | ";
if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eGeneratePrefixNalu ) if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eGeneratePrefixNalu )
result += "GeneratePrefixNalu | "; result += "GeneratePrefixNalu | ";
if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eMbQpDiffWraparound )
result += "MbQpDiffWraparound | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
@@ -2336,6 +2359,8 @@ namespace VULKAN_HPP_NAMESPACE
result += "MultipleTilesPerSliceSegment | "; result += "MultipleTilesPerSliceSegment | ";
if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eMultipleSliceSegmentsPerTile ) if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eMultipleSliceSegmentsPerTile )
result += "MultipleSliceSegmentsPerTile | "; result += "MultipleSliceSegmentsPerTile | ";
if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eCuQpDiffWraparound )
result += "CuQpDiffWraparound | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
@@ -2915,9 +2940,18 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_KHR_video_encode_queue === //=== VK_KHR_video_encode_queue ===
VULKAN_HPP_INLINE std::string to_string( VideoEncodeFlagsKHR ) VULKAN_HPP_INLINE std::string to_string( VideoEncodeFlagsKHR value )
{ {
if ( !value )
return "{}"; return "{}";
std::string result;
if ( value & VideoEncodeFlagBitsKHR::eWithQuantizationDeltaMap )
result += "WithQuantizationDeltaMap | ";
if ( value & VideoEncodeFlagBitsKHR::eWithEmphasisMap )
result += "WithEmphasisMap | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
VULKAN_HPP_INLINE std::string to_string( VideoEncodeCapabilityFlagsKHR value ) VULKAN_HPP_INLINE std::string to_string( VideoEncodeCapabilityFlagsKHR value )
@@ -2930,6 +2964,13 @@ namespace VULKAN_HPP_NAMESPACE
result += "PrecedingExternallyEncodedBytes | "; result += "PrecedingExternallyEncodedBytes | ";
if ( value & VideoEncodeCapabilityFlagBitsKHR::eInsufficientBitstreamBufferRangeDetection ) if ( value & VideoEncodeCapabilityFlagBitsKHR::eInsufficientBitstreamBufferRangeDetection )
result += "InsufficientBitstreamBufferRangeDetection | "; result += "InsufficientBitstreamBufferRangeDetection | ";
<<<<<<< HEAD
=======
if ( value & VideoEncodeCapabilityFlagBitsKHR::eQuantizationDeltaMap )
result += "QuantizationDeltaMap | ";
if ( value & VideoEncodeCapabilityFlagBitsKHR::eEmphasisMap )
result += "EmphasisMap | ";
>>>>>>> indev
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
@@ -3549,6 +3590,81 @@ namespace VULKAN_HPP_NAMESPACE
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
<<<<<<< HEAD
=======
//=== VK_KHR_video_encode_av1 ===
VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1CapabilityFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::ePerRateControlGroupMinMaxQIndex )
result += "PerRateControlGroupMinMaxQIndex | ";
if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::eGenerateObuExtensionHeader )
result += "GenerateObuExtensionHeader | ";
if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::ePrimaryReferenceCdfOnly )
result += "PrimaryReferenceCdfOnly | ";
if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::eFrameSizeOverride )
result += "FrameSizeOverride | ";
if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::eMotionVectorScaling )
result += "MotionVectorScaling | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1StdFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoEncodeAV1StdFlagBitsKHR::eUniformTileSpacingFlagSet )
result += "UniformTileSpacingFlagSet | ";
if ( value & VideoEncodeAV1StdFlagBitsKHR::eSkipModePresentUnset )
result += "SkipModePresentUnset | ";
if ( value & VideoEncodeAV1StdFlagBitsKHR::ePrimaryRefFrame )
result += "PrimaryRefFrame | ";
if ( value & VideoEncodeAV1StdFlagBitsKHR::eDeltaQ )
result += "DeltaQ | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1SuperblockSizeFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoEncodeAV1SuperblockSizeFlagBitsKHR::e64 )
result += "64 | ";
if ( value & VideoEncodeAV1SuperblockSizeFlagBitsKHR::e128 )
result += "128 | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1RateControlFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoEncodeAV1RateControlFlagBitsKHR::eRegularGop )
result += "RegularGop | ";
if ( value & VideoEncodeAV1RateControlFlagBitsKHR::eTemporalLayerPatternDyadic )
result += "TemporalLayerPatternDyadic | ";
if ( value & VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternFlat )
result += "ReferencePatternFlat | ";
if ( value & VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternDyadic )
result += "ReferencePatternDyadic | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
>>>>>>> indev
//=== VK_EXT_device_generated_commands === //=== VK_EXT_device_generated_commands ===
VULKAN_HPP_INLINE std::string to_string( IndirectCommandsLayoutUsageFlagsEXT value ) VULKAN_HPP_INLINE std::string to_string( IndirectCommandsLayoutUsageFlagsEXT value )
@@ -3935,6 +4051,7 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eCuModuleCreateInfoNVX: return "CuModuleCreateInfoNVX"; case StructureType::eCuModuleCreateInfoNVX: return "CuModuleCreateInfoNVX";
case StructureType::eCuFunctionCreateInfoNVX: return "CuFunctionCreateInfoNVX"; case StructureType::eCuFunctionCreateInfoNVX: return "CuFunctionCreateInfoNVX";
case StructureType::eCuLaunchInfoNVX: return "CuLaunchInfoNVX"; case StructureType::eCuLaunchInfoNVX: return "CuLaunchInfoNVX";
case StructureType::eCuModuleTexturingModeCreateInfoNVX: return "CuModuleTexturingModeCreateInfoNVX";
case StructureType::eImageViewHandleInfoNVX: return "ImageViewHandleInfoNVX"; case StructureType::eImageViewHandleInfoNVX: return "ImageViewHandleInfoNVX";
case StructureType::eImageViewAddressPropertiesNVX: return "ImageViewAddressPropertiesNVX"; case StructureType::eImageViewAddressPropertiesNVX: return "ImageViewAddressPropertiesNVX";
case StructureType::eVideoEncodeH264CapabilitiesKHR: return "VideoEncodeH264CapabilitiesKHR"; case StructureType::eVideoEncodeH264CapabilitiesKHR: return "VideoEncodeH264CapabilitiesKHR";
@@ -4582,6 +4699,17 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eVideoDecodeAv1ProfileInfoKHR: return "VideoDecodeAv1ProfileInfoKHR"; case StructureType::eVideoDecodeAv1ProfileInfoKHR: return "VideoDecodeAv1ProfileInfoKHR";
case StructureType::eVideoDecodeAv1SessionParametersCreateInfoKHR: return "VideoDecodeAv1SessionParametersCreateInfoKHR"; case StructureType::eVideoDecodeAv1SessionParametersCreateInfoKHR: return "VideoDecodeAv1SessionParametersCreateInfoKHR";
case StructureType::eVideoDecodeAv1DpbSlotInfoKHR: return "VideoDecodeAv1DpbSlotInfoKHR"; case StructureType::eVideoDecodeAv1DpbSlotInfoKHR: return "VideoDecodeAv1DpbSlotInfoKHR";
case StructureType::eVideoEncodeAv1CapabilitiesKHR: return "VideoEncodeAv1CapabilitiesKHR";
case StructureType::eVideoEncodeAv1SessionParametersCreateInfoKHR: return "VideoEncodeAv1SessionParametersCreateInfoKHR";
case StructureType::eVideoEncodeAv1PictureInfoKHR: return "VideoEncodeAv1PictureInfoKHR";
case StructureType::eVideoEncodeAv1DpbSlotInfoKHR: return "VideoEncodeAv1DpbSlotInfoKHR";
case StructureType::ePhysicalDeviceVideoEncodeAv1FeaturesKHR: return "PhysicalDeviceVideoEncodeAv1FeaturesKHR";
case StructureType::eVideoEncodeAv1ProfileInfoKHR: return "VideoEncodeAv1ProfileInfoKHR";
case StructureType::eVideoEncodeAv1RateControlInfoKHR: return "VideoEncodeAv1RateControlInfoKHR";
case StructureType::eVideoEncodeAv1RateControlLayerInfoKHR: return "VideoEncodeAv1RateControlLayerInfoKHR";
case StructureType::eVideoEncodeAv1QualityLevelPropertiesKHR: return "VideoEncodeAv1QualityLevelPropertiesKHR";
case StructureType::eVideoEncodeAv1SessionCreateInfoKHR: return "VideoEncodeAv1SessionCreateInfoKHR";
case StructureType::eVideoEncodeAv1GopRemainingFrameInfoKHR: return "VideoEncodeAv1GopRemainingFrameInfoKHR";
case StructureType::ePhysicalDeviceVideoMaintenance1FeaturesKHR: return "PhysicalDeviceVideoMaintenance1FeaturesKHR"; case StructureType::ePhysicalDeviceVideoMaintenance1FeaturesKHR: return "PhysicalDeviceVideoMaintenance1FeaturesKHR";
case StructureType::eVideoInlineQueryInfoKHR: return "VideoInlineQueryInfoKHR"; case StructureType::eVideoInlineQueryInfoKHR: return "VideoInlineQueryInfoKHR";
case StructureType::ePhysicalDevicePerStageDescriptorSetFeaturesNV: return "PhysicalDevicePerStageDescriptorSetFeaturesNV"; case StructureType::ePhysicalDevicePerStageDescriptorSetFeaturesNV: return "PhysicalDevicePerStageDescriptorSetFeaturesNV";
@@ -4623,6 +4751,18 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eSetDescriptorBufferOffsetsInfoEXT: return "SetDescriptorBufferOffsetsInfoEXT"; case StructureType::eSetDescriptorBufferOffsetsInfoEXT: return "SetDescriptorBufferOffsetsInfoEXT";
case StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT: return "BindDescriptorBufferEmbeddedSamplersInfoEXT"; case StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT: return "BindDescriptorBufferEmbeddedSamplersInfoEXT";
case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV: return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV"; case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV: return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV";
case StructureType::eDisplaySurfaceStereoCreateInfoNV: return "DisplaySurfaceStereoCreateInfoNV";
case StructureType::eDisplayModeStereoPropertiesNV: return "DisplayModeStereoPropertiesNV";
case StructureType::eVideoEncodeQuantizationMapCapabilitiesKHR: return "VideoEncodeQuantizationMapCapabilitiesKHR";
case StructureType::eVideoFormatQuantizationMapPropertiesKHR: return "VideoFormatQuantizationMapPropertiesKHR";
case StructureType::eVideoEncodeQuantizationMapInfoKHR: return "VideoEncodeQuantizationMapInfoKHR";
case StructureType::eVideoEncodeQuantizationMapSessionParametersCreateInfoKHR: return "VideoEncodeQuantizationMapSessionParametersCreateInfoKHR";
case StructureType::ePhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR: return "PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR";
case StructureType::eVideoEncodeH264QuantizationMapCapabilitiesKHR: return "VideoEncodeH264QuantizationMapCapabilitiesKHR";
case StructureType::eVideoEncodeH265QuantizationMapCapabilitiesKHR: return "VideoEncodeH265QuantizationMapCapabilitiesKHR";
case StructureType::eVideoFormatH265QuantizationMapPropertiesKHR: return "VideoFormatH265QuantizationMapPropertiesKHR";
case StructureType::eVideoEncodeAv1QuantizationMapCapabilitiesKHR: return "VideoEncodeAv1QuantizationMapCapabilitiesKHR";
case StructureType::eVideoFormatAv1QuantizationMapPropertiesKHR: return "VideoFormatAv1QuantizationMapPropertiesKHR";
case StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV: return "PhysicalDeviceRawAccessChainsFeaturesNV"; case StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV: return "PhysicalDeviceRawAccessChainsFeaturesNV";
case StructureType::ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR: return "PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR"; case StructureType::ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR: return "PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR";
case StructureType::ePhysicalDeviceCommandBufferInheritanceFeaturesNV: return "PhysicalDeviceCommandBufferInheritanceFeaturesNV"; case StructureType::ePhysicalDeviceCommandBufferInheritanceFeaturesNV: return "PhysicalDeviceCommandBufferInheritanceFeaturesNV";
@@ -4658,6 +4798,10 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceCooperativeMatrix2FeaturesNV: return "PhysicalDeviceCooperativeMatrix2FeaturesNV"; case StructureType::ePhysicalDeviceCooperativeMatrix2FeaturesNV: return "PhysicalDeviceCooperativeMatrix2FeaturesNV";
case StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV: return "CooperativeMatrixFlexibleDimensionsPropertiesNV"; case StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV: return "CooperativeMatrixFlexibleDimensionsPropertiesNV";
case StructureType::ePhysicalDeviceCooperativeMatrix2PropertiesNV: return "PhysicalDeviceCooperativeMatrix2PropertiesNV"; case StructureType::ePhysicalDeviceCooperativeMatrix2PropertiesNV: return "PhysicalDeviceCooperativeMatrix2PropertiesNV";
<<<<<<< HEAD
=======
case StructureType::ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT: return "PhysicalDeviceVertexAttributeRobustnessFeaturesEXT";
>>>>>>> indev
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }
@@ -5126,6 +5270,8 @@ namespace VULKAN_HPP_NAMESPACE
case ImageUsageFlagBits::eInvocationMaskHUAWEI: return "InvocationMaskHUAWEI"; case ImageUsageFlagBits::eInvocationMaskHUAWEI: return "InvocationMaskHUAWEI";
case ImageUsageFlagBits::eSampleWeightQCOM: return "SampleWeightQCOM"; case ImageUsageFlagBits::eSampleWeightQCOM: return "SampleWeightQCOM";
case ImageUsageFlagBits::eSampleBlockMatchQCOM: return "SampleBlockMatchQCOM"; case ImageUsageFlagBits::eSampleBlockMatchQCOM: return "SampleBlockMatchQCOM";
case ImageUsageFlagBits::eVideoEncodeQuantizationDeltaMapKHR: return "VideoEncodeQuantizationDeltaMapKHR";
case ImageUsageFlagBits::eVideoEncodeEmphasisMapKHR: return "VideoEncodeEmphasisMapKHR";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }
@@ -5517,6 +5663,7 @@ namespace VULKAN_HPP_NAMESPACE
case ImageLayout::eVideoEncodeSrcKHR: return "VideoEncodeSrcKHR"; case ImageLayout::eVideoEncodeSrcKHR: return "VideoEncodeSrcKHR";
case ImageLayout::eVideoEncodeDpbKHR: return "VideoEncodeDpbKHR"; case ImageLayout::eVideoEncodeDpbKHR: return "VideoEncodeDpbKHR";
case ImageLayout::eAttachmentFeedbackLoopOptimalEXT: return "AttachmentFeedbackLoopOptimalEXT"; case ImageLayout::eAttachmentFeedbackLoopOptimalEXT: return "AttachmentFeedbackLoopOptimalEXT";
case ImageLayout::eVideoEncodeQuantizationMapKHR: return "VideoEncodeQuantizationMapKHR";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }
@@ -6891,6 +7038,8 @@ namespace VULKAN_HPP_NAMESPACE
case FormatFeatureFlagBits2::eOpticalFlowImageNV: return "OpticalFlowImageNV"; case FormatFeatureFlagBits2::eOpticalFlowImageNV: return "OpticalFlowImageNV";
case FormatFeatureFlagBits2::eOpticalFlowVectorNV: return "OpticalFlowVectorNV"; case FormatFeatureFlagBits2::eOpticalFlowVectorNV: return "OpticalFlowVectorNV";
case FormatFeatureFlagBits2::eOpticalFlowCostNV: return "OpticalFlowCostNV"; case FormatFeatureFlagBits2::eOpticalFlowCostNV: return "OpticalFlowCostNV";
case FormatFeatureFlagBits2::eVideoEncodeQuantizationDeltaMapKHR: return "VideoEncodeQuantizationDeltaMapKHR";
case FormatFeatureFlagBits2::eVideoEncodeEmphasisMapKHR: return "VideoEncodeEmphasisMapKHR";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }
@@ -7152,6 +7301,7 @@ namespace VULKAN_HPP_NAMESPACE
case VideoCodecOperationFlagBitsKHR::eDecodeH264: return "DecodeH264"; case VideoCodecOperationFlagBitsKHR::eDecodeH264: return "DecodeH264";
case VideoCodecOperationFlagBitsKHR::eDecodeH265: return "DecodeH265"; case VideoCodecOperationFlagBitsKHR::eDecodeH265: return "DecodeH265";
case VideoCodecOperationFlagBitsKHR::eDecodeAv1: return "DecodeAv1"; case VideoCodecOperationFlagBitsKHR::eDecodeAv1: return "DecodeAv1";
case VideoCodecOperationFlagBitsKHR::eEncodeAv1: return "EncodeAv1";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }
@@ -7198,6 +7348,8 @@ namespace VULKAN_HPP_NAMESPACE
case VideoSessionCreateFlagBitsKHR::eProtectedContent: return "ProtectedContent"; case VideoSessionCreateFlagBitsKHR::eProtectedContent: return "ProtectedContent";
case VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations: return "AllowEncodeParameterOptimizations"; case VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations: return "AllowEncodeParameterOptimizations";
case VideoSessionCreateFlagBitsKHR::eInlineQueries: return "InlineQueries"; case VideoSessionCreateFlagBitsKHR::eInlineQueries: return "InlineQueries";
case VideoSessionCreateFlagBitsKHR::eAllowEncodeQuantizationDeltaMap: return "AllowEncodeQuantizationDeltaMap";
case VideoSessionCreateFlagBitsKHR::eAllowEncodeEmphasisMap: return "AllowEncodeEmphasisMap";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }
@@ -7225,9 +7377,13 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
VULKAN_HPP_INLINE std::string to_string( VideoSessionParametersCreateFlagBitsKHR ) VULKAN_HPP_INLINE std::string to_string( VideoSessionParametersCreateFlagBitsKHR value )
{ {
return "(void)"; switch ( value )
{
case VideoSessionParametersCreateFlagBitsKHR::eQuantizationMapCompatible: return "QuantizationMapCompatible";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
} }
VULKAN_HPP_INLINE std::string to_string( VideoBeginCodingFlagBitsKHR ) VULKAN_HPP_INLINE std::string to_string( VideoBeginCodingFlagBitsKHR )
@@ -7291,6 +7447,7 @@ namespace VULKAN_HPP_NAMESPACE
case VideoEncodeH264CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp: return "PerPictureTypeMinMaxQp"; case VideoEncodeH264CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp: return "PerPictureTypeMinMaxQp";
case VideoEncodeH264CapabilityFlagBitsKHR::ePerSliceConstantQp: return "PerSliceConstantQp"; case VideoEncodeH264CapabilityFlagBitsKHR::ePerSliceConstantQp: return "PerSliceConstantQp";
case VideoEncodeH264CapabilityFlagBitsKHR::eGeneratePrefixNalu: return "GeneratePrefixNalu"; case VideoEncodeH264CapabilityFlagBitsKHR::eGeneratePrefixNalu: return "GeneratePrefixNalu";
case VideoEncodeH264CapabilityFlagBitsKHR::eMbQpDiffWraparound: return "MbQpDiffWraparound";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }
@@ -7352,6 +7509,7 @@ namespace VULKAN_HPP_NAMESPACE
case VideoEncodeH265CapabilityFlagBitsKHR::ePerSliceSegmentConstantQp: return "PerSliceSegmentConstantQp"; case VideoEncodeH265CapabilityFlagBitsKHR::ePerSliceSegmentConstantQp: return "PerSliceSegmentConstantQp";
case VideoEncodeH265CapabilityFlagBitsKHR::eMultipleTilesPerSliceSegment: return "MultipleTilesPerSliceSegment"; case VideoEncodeH265CapabilityFlagBitsKHR::eMultipleTilesPerSliceSegment: return "MultipleTilesPerSliceSegment";
case VideoEncodeH265CapabilityFlagBitsKHR::eMultipleSliceSegmentsPerTile: return "MultipleSliceSegmentsPerTile"; case VideoEncodeH265CapabilityFlagBitsKHR::eMultipleSliceSegmentsPerTile: return "MultipleSliceSegmentsPerTile";
case VideoEncodeH265CapabilityFlagBitsKHR::eCuQpDiffWraparound: return "CuQpDiffWraparound";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }
@@ -8363,6 +8521,11 @@ namespace VULKAN_HPP_NAMESPACE
{ {
case VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes: return "PrecedingExternallyEncodedBytes"; case VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes: return "PrecedingExternallyEncodedBytes";
case VideoEncodeCapabilityFlagBitsKHR::eInsufficientBitstreamBufferRangeDetection: return "InsufficientBitstreamBufferRangeDetection"; case VideoEncodeCapabilityFlagBitsKHR::eInsufficientBitstreamBufferRangeDetection: return "InsufficientBitstreamBufferRangeDetection";
<<<<<<< HEAD
=======
case VideoEncodeCapabilityFlagBitsKHR::eQuantizationDeltaMap: return "QuantizationDeltaMap";
case VideoEncodeCapabilityFlagBitsKHR::eEmphasisMap: return "EmphasisMap";
>>>>>>> indev
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }
@@ -8428,9 +8591,14 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
VULKAN_HPP_INLINE std::string to_string( VideoEncodeFlagBitsKHR ) VULKAN_HPP_INLINE std::string to_string( VideoEncodeFlagBitsKHR value )
{ {
return "(void)"; switch ( value )
{
case VideoEncodeFlagBitsKHR::eWithQuantizationDeltaMap: return "WithQuantizationDeltaMap";
case VideoEncodeFlagBitsKHR::eWithEmphasisMap: return "WithEmphasisMap";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
} }
VULKAN_HPP_INLINE std::string to_string( VideoEncodeRateControlFlagBitsKHR ) VULKAN_HPP_INLINE std::string to_string( VideoEncodeRateControlFlagBitsKHR )
@@ -9149,6 +9317,78 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
//=== VK_KHR_video_encode_av1 ===
VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1PredictionModeKHR value )
{
switch ( value )
{
case VideoEncodeAV1PredictionModeKHR::eIntraOnly: return "IntraOnly";
case VideoEncodeAV1PredictionModeKHR::eSingleReference: return "SingleReference";
case VideoEncodeAV1PredictionModeKHR::eUnidirectionalCompound: return "UnidirectionalCompound";
case VideoEncodeAV1PredictionModeKHR::eBidirectionalCompound: return "BidirectionalCompound";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1RateControlGroupKHR value )
{
switch ( value )
{
case VideoEncodeAV1RateControlGroupKHR::eIntra: return "Intra";
case VideoEncodeAV1RateControlGroupKHR::ePredictive: return "Predictive";
case VideoEncodeAV1RateControlGroupKHR::eBipredictive: return "Bipredictive";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1CapabilityFlagBitsKHR value )
{
switch ( value )
{
case VideoEncodeAV1CapabilityFlagBitsKHR::ePerRateControlGroupMinMaxQIndex: return "PerRateControlGroupMinMaxQIndex";
case VideoEncodeAV1CapabilityFlagBitsKHR::eGenerateObuExtensionHeader: return "GenerateObuExtensionHeader";
case VideoEncodeAV1CapabilityFlagBitsKHR::ePrimaryReferenceCdfOnly: return "PrimaryReferenceCdfOnly";
case VideoEncodeAV1CapabilityFlagBitsKHR::eFrameSizeOverride: return "FrameSizeOverride";
case VideoEncodeAV1CapabilityFlagBitsKHR::eMotionVectorScaling: return "MotionVectorScaling";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1StdFlagBitsKHR value )
{
switch ( value )
{
case VideoEncodeAV1StdFlagBitsKHR::eUniformTileSpacingFlagSet: return "UniformTileSpacingFlagSet";
case VideoEncodeAV1StdFlagBitsKHR::eSkipModePresentUnset: return "SkipModePresentUnset";
case VideoEncodeAV1StdFlagBitsKHR::ePrimaryRefFrame: return "PrimaryRefFrame";
case VideoEncodeAV1StdFlagBitsKHR::eDeltaQ: return "DeltaQ";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1SuperblockSizeFlagBitsKHR value )
{
switch ( value )
{
case VideoEncodeAV1SuperblockSizeFlagBitsKHR::e64: return "64";
case VideoEncodeAV1SuperblockSizeFlagBitsKHR::e128: return "128";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1RateControlFlagBitsKHR value )
{
switch ( value )
{
case VideoEncodeAV1RateControlFlagBitsKHR::eRegularGop: return "RegularGop";
case VideoEncodeAV1RateControlFlagBitsKHR::eTemporalLayerPatternDyadic: return "TemporalLayerPatternDyadic";
case VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternFlat: return "ReferencePatternFlat";
case VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternDyadic: return "ReferencePatternDyadic";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
//=== VK_QCOM_image_processing2 === //=== VK_QCOM_image_processing2 ===
VULKAN_HPP_INLINE std::string to_string( BlockMatchWindowCompareModeQCOM value ) VULKAN_HPP_INLINE std::string to_string( BlockMatchWindowCompareModeQCOM value )
@@ -9215,6 +9455,23 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
<<<<<<< HEAD
=======
//=== VK_NV_display_stereo ===
VULKAN_HPP_INLINE std::string to_string( DisplaySurfaceStereoTypeNV value )
{
switch ( value )
{
case DisplaySurfaceStereoTypeNV::eNone: return "None";
case DisplaySurfaceStereoTypeNV::eOnboardDin: return "OnboardDin";
case DisplaySurfaceStereoTypeNV::eHdmi3D: return "Hdmi3D";
case DisplaySurfaceStereoTypeNV::eInbandDisplayport: return "InbandDisplayport";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
>>>>>>> indev
//=== VK_KHR_maintenance7 === //=== VK_KHR_maintenance7 ===
VULKAN_HPP_INLINE std::string to_string( PhysicalDeviceLayeredApiKHR value ) VULKAN_HPP_INLINE std::string to_string( PhysicalDeviceLayeredApiKHR value )

93
valgrind.supp
View File

@@ -73,29 +73,88 @@
... ...
} }
{ {
name memcheck_malloc_suppressions
Memcheck:Leak Memcheck:Leak
fun:* fun:malloc
obj:*
... ...
fun:_dl_* obj:/var/cache/nscd/passwd
}
{
memcheck_calloc_suppressions
Memcheck:Leak
fun:calloc
...
obj:/var/cache/nscd/passwd
}
{
memcheck_realloc_suppressions
Memcheck:Leak
fun:realloc
...
obj:/var/cache/nscd/passwd
}
{
dl_catch_exception_suppressions
Memcheck:Leak
...
fun:_dl_catch_exception
... ...
} }
{ {
name dl_catch_exception_suppressions_addr8
Memcheck:Leak
fun:*
obj:*
...
fun:dl_*
...
}
{
name
Memcheck:Addr8 Memcheck:Addr8
fun:*
obj:*
... ...
fun:dl_* fun:_dl_catch_exception
...
}
{
dlopen_malloc-suppressions
Memcheck:Leak
match-leak-kinds: definite
fun:malloc
...
fun:_dl_open
...
}
{
_dl_init_suppressions
Memcheck:Leak
match-leak-kinds: reachable
fun:_Znwm
...
fun:_dl_init
}
{
dbus_suppressions
Memcheck:Leak
match-leak-kinds: reachable
...
fun:_dbus*
...
}
{
dbus_memory_leak
Memcheck:Leak
match-leak-kinds: definite
fun:calloc
obj:/usr/lib/x86_64-linux-gnu/libdbus-1.so.*
...
fun:dbus*
...
}
{
name
Memcheck:Leak
fun:*
...
obj:*libnvidia-glcore.so*
...
}
{
name
Memcheck:Leak
fun:*
...
obj:*libdbus-1.so*
... ...
} }