mirror of
https://github.com/seekrs/MacroLibX.git
synced 2026-04-25 16:21:26 +02:00
trying to fix merge conflicts
This commit is contained in:
2
.github/workflows/linux_clang.yml
vendored
2
.github/workflows/linux_clang.yml
vendored
@@ -35,7 +35,7 @@ jobs:
|
||||
|
||||
# Build the lib
|
||||
- name: Build MacroLibX
|
||||
run: make -j && make fclean && make -j DEBUG=true
|
||||
run: make -j && make fclean && make debug
|
||||
|
||||
# Build the example
|
||||
- name: Build Example
|
||||
|
||||
2
.github/workflows/linux_gcc.yml
vendored
2
.github/workflows/linux_gcc.yml
vendored
@@ -35,7 +35,7 @@ jobs:
|
||||
|
||||
# Build the lib
|
||||
- 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
|
||||
- name: Build Example
|
||||
|
||||
2
.github/workflows/macos_x86.yml
vendored
2
.github/workflows/macos_x86.yml
vendored
@@ -35,7 +35,7 @@ jobs:
|
||||
|
||||
# Build the lib
|
||||
- name: Build MacroLibX
|
||||
run: make -j && make fclean && make DEBUG=true -j
|
||||
run: make -j && make fclean && make debug
|
||||
|
||||
# Build the example
|
||||
- name: Build Example
|
||||
|
||||
1
Makefile
1
Makefile
@@ -168,6 +168,7 @@ clean:
|
||||
fclean: clean
|
||||
@$(RM) $(NAME)
|
||||
@printf "Cleaned $(_BOLD)$(NAME)$(_RESET)\n"
|
||||
@printf "Cleaned $(_BOLD)$(NAME)$(_RESET)\n"
|
||||
|
||||
re: fclean _printbuildinfos
|
||||
@$(MAKE) $(NAME)
|
||||
|
||||
@@ -132,7 +132,7 @@ typedef enum StdVideoAV1FrameRestorationType {
|
||||
|
||||
typedef enum StdVideoAV1ColorPrimaries {
|
||||
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_B_G = 5,
|
||||
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_EBU_3213 = 22,
|
||||
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
|
||||
} StdVideoAV1ColorPrimaries;
|
||||
|
||||
|
||||
143
third_party/vk_video/vulkan_video_codec_av1std_encode.h
vendored
git.filemode.normal_file
143
third_party/vk_video/vulkan_video_codec_av1std_encode.h
vendored
git.filemode.normal_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
75
third_party/vulkan/vulkan.cppm
vendored
@@ -872,6 +872,18 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::ScopeKHR;
|
||||
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 ===
|
||||
using VULKAN_HPP_NAMESPACE::BlockMatchWindowCompareModeQCOM;
|
||||
|
||||
@@ -889,6 +901,12 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::TimeDomainEXT;
|
||||
using VULKAN_HPP_NAMESPACE::TimeDomainKHR;
|
||||
|
||||
<<<<<<< HEAD
|
||||
=======
|
||||
//=== VK_NV_display_stereo ===
|
||||
using VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoTypeNV;
|
||||
|
||||
>>>>>>> indev
|
||||
//=== VK_KHR_maintenance7 ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiKHR;
|
||||
|
||||
@@ -2498,6 +2516,10 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::KHRVideoDecodeAv1SpecVersion;
|
||||
using VULKAN_HPP_NAMESPACE::MaxVideoAv1ReferencesPerFrameKHR;
|
||||
|
||||
//=== VK_KHR_video_encode_av1 ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRVideoEncodeAv1ExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRVideoEncodeAv1SpecVersion;
|
||||
|
||||
//=== VK_KHR_video_maintenance1 ===
|
||||
using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance1ExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance1SpecVersion;
|
||||
@@ -2572,6 +2594,14 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationExtensionName;
|
||||
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 ===
|
||||
using VULKAN_HPP_NAMESPACE::NVRawAccessChainsExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVRawAccessChainsSpecVersion;
|
||||
@@ -2620,6 +2650,13 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::NVCooperativeMatrix2ExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::NVCooperativeMatrix2SpecVersion;
|
||||
|
||||
<<<<<<< HEAD
|
||||
=======
|
||||
//=== VK_EXT_vertex_attribute_robustness ===
|
||||
using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessExtensionName;
|
||||
using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessSpecVersion;
|
||||
|
||||
>>>>>>> indev
|
||||
//========================
|
||||
//=== CONSTEXPR VALUEs ===
|
||||
//========================
|
||||
@@ -3209,6 +3246,7 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX;
|
||||
using VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX;
|
||||
using VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX;
|
||||
using VULKAN_HPP_NAMESPACE::CuModuleTexturingModeCreateInfoNVX;
|
||||
|
||||
//=== VK_NVX_image_view_handle ===
|
||||
using VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX;
|
||||
@@ -4400,6 +4438,21 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR;
|
||||
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 ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR;
|
||||
using VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR;
|
||||
@@ -4484,6 +4537,22 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_NV_descriptor_pool_overallocation ===
|
||||
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 ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV;
|
||||
|
||||
@@ -4553,6 +4622,12 @@ export namespace VULKAN_HPP_NAMESPACE
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV;
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV;
|
||||
|
||||
<<<<<<< HEAD
|
||||
=======
|
||||
//=== VK_EXT_vertex_attribute_robustness ===
|
||||
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT;
|
||||
|
||||
>>>>>>> indev
|
||||
//===============
|
||||
//=== HANDLEs ===
|
||||
//===============
|
||||
|
||||
8423
third_party/vulkan/vulkan.hpp
vendored
8423
third_party/vulkan/vulkan.hpp
vendored
File diff suppressed because it is too large
Load Diff
710
third_party/vulkan/vulkan_core.h
vendored
710
third_party/vulkan/vulkan_core.h
vendored
File diff suppressed because it is too large
Load Diff
563
third_party/vulkan/vulkan_enums.hpp
vendored
563
third_party/vulkan/vulkan_enums.hpp
vendored
File diff suppressed because it is too large
Load Diff
@@ -8,6 +8,15 @@
|
||||
#ifndef 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 )
|
||||
import VULKAN_HPP_STD_MODULE;
|
||||
#else
|
||||
@@ -46,7 +55,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
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_NV_glsl_shader", "" },
|
||||
{ "VK_NV_dedicated_allocation", "VK_KHR_dedicated_allocation" },
|
||||
@@ -68,6 +77,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
|
||||
{ "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_EXT_buffer_device_address", "VK_KHR_buffer_device_address" },
|
||||
{ "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()
|
||||
{
|
||||
static std::set<std::string> deviceExtensions = {
|
||||
static const std::set<std::string> deviceExtensions = {
|
||||
"VK_KHR_swapchain",
|
||||
"VK_KHR_display_swapchain",
|
||||
"VK_NV_glsl_shader",
|
||||
@@ -347,6 +357,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
"VK_EXT_primitive_topology_list_restart",
|
||||
"VK_KHR_format_feature_flags2",
|
||||
"VK_EXT_present_mode_fifo_latest_ready",
|
||||
"VK_EXT_present_mode_fifo_latest_ready",
|
||||
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
||||
"VK_FUCHSIA_external_memory",
|
||||
"VK_FUCHSIA_external_semaphore",
|
||||
@@ -406,9 +417,11 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
||||
"VK_KHR_maintenance5",
|
||||
"VK_AMD_anti_lag",
|
||||
"VK_AMD_anti_lag",
|
||||
"VK_KHR_ray_tracing_position_fetch",
|
||||
"VK_EXT_shader_object",
|
||||
"VK_KHR_pipeline_binary",
|
||||
"VK_KHR_pipeline_binary",
|
||||
"VK_QCOM_tile_properties",
|
||||
"VK_SEC_amigo_profiling",
|
||||
"VK_QCOM_multiview_per_view_viewports",
|
||||
@@ -416,6 +429,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
"VK_NV_extended_sparse_address_space",
|
||||
"VK_EXT_mutable_descriptor_type",
|
||||
"VK_EXT_legacy_vertex_attributes",
|
||||
"VK_EXT_legacy_vertex_attributes",
|
||||
"VK_ARM_shader_core_builtins",
|
||||
"VK_EXT_pipeline_library_group_handles",
|
||||
"VK_EXT_dynamic_rendering_unused_attachments",
|
||||
@@ -423,7 +437,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
"VK_KHR_cooperative_matrix",
|
||||
"VK_QCOM_multiview_per_view_render_areas",
|
||||
"VK_KHR_compute_shader_derivatives",
|
||||
"VK_KHR_compute_shader_derivatives",
|
||||
"VK_KHR_video_decode_av1",
|
||||
"VK_KHR_video_encode_av1",
|
||||
"VK_KHR_video_maintenance1",
|
||||
"VK_NV_per_stage_descriptor_set",
|
||||
"VK_QCOM_image_processing2",
|
||||
@@ -444,10 +460,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
"VK_KHR_shader_expect_assume",
|
||||
"VK_KHR_maintenance6",
|
||||
"VK_NV_descriptor_pool_overallocation",
|
||||
"VK_KHR_video_encode_quantization_map",
|
||||
"VK_NV_raw_access_chains",
|
||||
"VK_KHR_shader_relaxed_extended_instruction",
|
||||
"VK_NV_command_buffer_inheritance",
|
||||
"VK_KHR_maintenance7",
|
||||
"VK_KHR_shader_relaxed_extended_instruction",
|
||||
"VK_NV_command_buffer_inheritance",
|
||||
"VK_KHR_maintenance7",
|
||||
"VK_NV_shader_atomic_float16_vector",
|
||||
"VK_EXT_shader_replicated_composites",
|
||||
"VK_NV_ray_tracing_validation",
|
||||
@@ -462,7 +482,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
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_display",
|
||||
#if defined( VK_USE_PLATFORM_XLIB_KHR )
|
||||
@@ -529,15 +549,16 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
"VK_KHR_portability_enumeration",
|
||||
"VK_GOOGLE_surfaceless_query",
|
||||
"VK_LUNARG_direct_driver_loading",
|
||||
"VK_EXT_layer_settings"
|
||||
"VK_EXT_layer_settings",
|
||||
"VK_NV_display_stereo"
|
||||
};
|
||||
return instanceExtensions;
|
||||
}
|
||||
|
||||
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 std::map<std::string, std::map<std::string, std::vector<std::vector<std::string>>>> dependencies = {
|
||||
static const std::map<std::string, std::vector<std::vector<std::string>>> noDependencies;
|
||||
static const std::map<std::string, std::map<std::string, std::vector<std::vector<std::string>>>> dependencies = {
|
||||
{ "VK_KHR_swapchain",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
@@ -999,9 +1020,12 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
"VK_KHR_synchronization2",
|
||||
"VK_KHR_spirv_1_4",
|
||||
"VK_EXT_extended_dynamic_state",
|
||||
"VK_KHR_spirv_1_4",
|
||||
"VK_EXT_extended_dynamic_state",
|
||||
} } },
|
||||
{ "VK_VERSION_1_3",
|
||||
{ {
|
||||
"VK_KHR_maintenance5",
|
||||
"VK_KHR_maintenance5",
|
||||
"VK_KHR_pipeline_library",
|
||||
} } } } },
|
||||
@@ -1833,6 +1857,11 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{ {
|
||||
"VK_KHR_swapchain",
|
||||
} } } } },
|
||||
{ "VK_EXT_present_mode_fifo_latest_ready",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_swapchain",
|
||||
} } } } },
|
||||
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
||||
{ "VK_FUCHSIA_external_memory",
|
||||
{ { "VK_VERSION_1_0",
|
||||
@@ -2172,6 +2201,11 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{ {
|
||||
"VK_KHR_maintenance5",
|
||||
} } } } },
|
||||
{ "VK_KHR_pipeline_binary",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_maintenance5",
|
||||
} } } } },
|
||||
{ "VK_QCOM_tile_properties",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
@@ -2205,6 +2239,11 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{ {
|
||||
"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_VERSION_1_0",
|
||||
{ {
|
||||
@@ -2244,11 +2283,21 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{ {
|
||||
"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_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_video_decode_queue",
|
||||
} } } } },
|
||||
{ "VK_KHR_video_encode_av1",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
"VK_KHR_video_encode_queue",
|
||||
} } } } },
|
||||
{ "VK_KHR_video_maintenance1",
|
||||
{ { "VK_VERSION_1_0",
|
||||
{ {
|
||||
@@ -2414,13 +2463,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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_EXT_debug_marker", "VK_EXT_debug_utils" },
|
||||
{ "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_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_fragment_shader_barycentric", "VK_KHR_fragment_shader_barycentric" },
|
||||
{ "VK_KHR_timeline_semaphore", "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";
|
||||
}
|
||||
if ( extension == "VK_NV_ray_tracing" )
|
||||
{
|
||||
return "VK_KHR_ray_tracing_pipeline";
|
||||
}
|
||||
if ( extension == "VK_EXT_buffer_device_address" )
|
||||
{
|
||||
return "VK_KHR_buffer_device_address";
|
||||
@@ -2799,6 +2853,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
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" )
|
||||
{
|
||||
return "VK_KHR_fragment_shader_barycentric";
|
||||
@@ -2959,6 +3017,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
#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_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 )
|
||||
@@ -3103,6 +3163,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
( 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_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 )
|
||||
|| ( extension == "VK_FUCHSIA_external_memory" ) || ( extension == "VK_FUCHSIA_external_semaphore" ) || ( extension == "VK_FUCHSIA_buffer_collection" )
|
||||
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
||||
@@ -3133,6 +3194,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
||||
|| ( extension == "VK_ANDROID_external_format_resolve" )
|
||||
#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_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" ) ||
|
||||
@@ -3216,7 +3280,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
|| ( extension == "VK_QNX_screen_surface" )
|
||||
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
||||
|| ( 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 )
|
||||
@@ -3259,6 +3323,16 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
( 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_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_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" ) ||
|
||||
|
||||
3768
third_party/vulkan/vulkan_funcs.hpp
vendored
3768
third_party/vulkan/vulkan_funcs.hpp
vendored
File diff suppressed because it is too large
Load Diff
76
third_party/vulkan/vulkan_handles.hpp
vendored
76
third_party/vulkan/vulkan_handles.hpp
vendored
@@ -572,6 +572,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
//=== VK_NVX_binary_import ===
|
||||
struct CuModuleCreateInfoNVX;
|
||||
struct CuModuleTexturingModeCreateInfoNVX;
|
||||
struct CuFunctionCreateInfoNVX;
|
||||
struct CuLaunchInfoNVX;
|
||||
|
||||
@@ -1765,6 +1766,21 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
struct VideoDecodeAV1PictureInfoKHR;
|
||||
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 ===
|
||||
struct PhysicalDeviceVideoMaintenance1FeaturesKHR;
|
||||
struct VideoInlineQueryInfoKHR;
|
||||
@@ -1849,6 +1865,22 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
//=== VK_NV_descriptor_pool_overallocation ===
|
||||
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 ===
|
||||
struct PhysicalDeviceRawAccessChainsFeaturesNV;
|
||||
|
||||
@@ -1918,6 +1950,12 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
struct PhysicalDeviceCooperativeMatrix2FeaturesNV;
|
||||
struct PhysicalDeviceCooperativeMatrix2PropertiesNV;
|
||||
|
||||
<<<<<<< HEAD
|
||||
=======
|
||||
//=== VK_EXT_vertex_attribute_robustness ===
|
||||
struct PhysicalDeviceVertexAttributeRobustnessFeaturesEXT;
|
||||
|
||||
>>>>>>> indev
|
||||
//===================================
|
||||
//=== HANDLE forward declarations ===
|
||||
//===================================
|
||||
@@ -12737,6 +12775,15 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
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>
|
||||
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>
|
||||
VULKAN_HPP_NODISCARD Result getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView,
|
||||
VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties,
|
||||
@@ -16805,6 +16852,21 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
|
||||
VideoFormatPropertiesKHRAllocator & videoFormatPropertiesKHRAllocator,
|
||||
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 */
|
||||
|
||||
//=== VK_NV_external_memory_capabilities ===
|
||||
@@ -17213,6 +17275,20 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
|
||||
DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator,
|
||||
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 */
|
||||
|
||||
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
|
||||
|
||||
434
third_party/vulkan/vulkan_hash.hpp
vendored
434
third_party/vulkan/vulkan_hash.hpp
vendored
@@ -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 )
|
||||
template <>
|
||||
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 <>
|
||||
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 <>
|
||||
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 <>
|
||||
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 <>
|
||||
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 <>
|
||||
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 <>
|
||||
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 <>
|
||||
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 <>
|
||||
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 <>
|
||||
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 <>
|
||||
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 <>
|
||||
struct hash<VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR>
|
||||
{
|
||||
|
||||
120
third_party/vulkan/vulkan_raii.hpp
vendored
120
third_party/vulkan/vulkan_raii.hpp
vendored
@@ -926,8 +926,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetDeviceProcAddr( device, "vkCmdCuLaunchKernelNVX" ) );
|
||||
|
||||
//=== VK_NVX_image_view_handle ===
|
||||
<<<<<<< HEAD
|
||||
vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) );
|
||||
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 ===
|
||||
vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) );
|
||||
@@ -1999,8 +2005,14 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0;
|
||||
|
||||
//=== VK_NVX_image_view_handle ===
|
||||
<<<<<<< HEAD
|
||||
PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0;
|
||||
PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0;
|
||||
=======
|
||||
PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0;
|
||||
PFN_vkGetImageViewHandle64NVX vkGetImageViewHandle64NVX = 0;
|
||||
PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0;
|
||||
>>>>>>> indev
|
||||
|
||||
//=== VK_AMD_draw_indirect_count ===
|
||||
PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0;
|
||||
@@ -3381,6 +3393,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>
|
||||
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 ===
|
||||
|
||||
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 uint64_t getImageViewHandle64NVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT;
|
||||
|
||||
//=== VK_KHR_device_group ===
|
||||
|
||||
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;
|
||||
|
||||
template <typename StructureChain>
|
||||
VULKAN_HPP_NODISCARD std::vector<StructureChain> getModeProperties2() const;
|
||||
|
||||
# if defined( VK_USE_PLATFORM_WIN32_KHR )
|
||||
//=== VK_NV_acquire_winrt_display ===
|
||||
|
||||
@@ -16397,6 +16418,52 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
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_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR>::Type
|
||||
Device::createVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo,
|
||||
@@ -16718,6 +16785,17 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
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_ASSERT( getDispatcher()->vkGetImageViewAddressNVX && "Function <vkGetImageViewAddressNVX> requires <VK_NVX_image_view_handle>" );
|
||||
@@ -18135,6 +18213,48 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
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
|
||||
PhysicalDevice::getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo ) const
|
||||
{
|
||||
|
||||
198
third_party/vulkan/vulkan_static_assertions.hpp
vendored
198
third_party/vulkan/vulkan_static_assertions.hpp
vendored
@@ -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,
|
||||
"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 ),
|
||||
"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!" );
|
||||
@@ -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,
|
||||
"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 ===
|
||||
|
||||
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,
|
||||
"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 ===
|
||||
|
||||
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,
|
||||
"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
|
||||
|
||||
3079
third_party/vulkan/vulkan_structs.hpp
vendored
3079
third_party/vulkan/vulkan_structs.hpp
vendored
File diff suppressed because it is too large
Load Diff
269
third_party/vulkan/vulkan_to_string.hpp
vendored
269
third_party/vulkan/vulkan_to_string.hpp
vendored
@@ -208,6 +208,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
result += "SampleWeightQCOM | ";
|
||||
if ( value & ImageUsageFlagBits::eSampleBlockMatchQCOM )
|
||||
result += "SampleBlockMatchQCOM | ";
|
||||
if ( value & ImageUsageFlagBits::eVideoEncodeQuantizationDeltaMapKHR )
|
||||
result += "VideoEncodeQuantizationDeltaMapKHR | ";
|
||||
if ( value & ImageUsageFlagBits::eVideoEncodeEmphasisMapKHR )
|
||||
result += "VideoEncodeEmphasisMapKHR | ";
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
@@ -1860,6 +1864,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
result += "OpticalFlowVectorNV | ";
|
||||
if ( value & FormatFeatureFlagBits2::eOpticalFlowCostNV )
|
||||
result += "OpticalFlowCostNV | ";
|
||||
if ( value & FormatFeatureFlagBits2::eVideoEncodeQuantizationDeltaMapKHR )
|
||||
result += "VideoEncodeQuantizationDeltaMapKHR | ";
|
||||
if ( value & FormatFeatureFlagBits2::eVideoEncodeEmphasisMapKHR )
|
||||
result += "VideoEncodeEmphasisMapKHR | ";
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
@@ -2065,6 +2073,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
result += "DecodeH265 | ";
|
||||
if ( value & VideoCodecOperationFlagBitsKHR::eDecodeAv1 )
|
||||
result += "DecodeAv1 | ";
|
||||
if ( value & VideoCodecOperationFlagBitsKHR::eEncodeAv1 )
|
||||
result += "EncodeAv1 | ";
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
@@ -2129,13 +2139,24 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
result += "AllowEncodeParameterOptimizations | ";
|
||||
if ( value & VideoSessionCreateFlagBitsKHR::eInlineQueries )
|
||||
result += "InlineQueries | ";
|
||||
if ( value & VideoSessionCreateFlagBitsKHR::eAllowEncodeQuantizationDeltaMap )
|
||||
result += "AllowEncodeQuantizationDeltaMap | ";
|
||||
if ( value & VideoSessionCreateFlagBitsKHR::eAllowEncodeEmphasisMap )
|
||||
result += "AllowEncodeEmphasisMap | ";
|
||||
|
||||
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 "{}";
|
||||
|
||||
std::string result;
|
||||
if ( value & VideoSessionParametersCreateFlagBitsKHR::eQuantizationMapCompatible )
|
||||
result += "QuantizationMapCompatible | ";
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( VideoBeginCodingFlagsKHR )
|
||||
@@ -2234,6 +2255,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
result += "PerSliceConstantQp | ";
|
||||
if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eGeneratePrefixNalu )
|
||||
result += "GeneratePrefixNalu | ";
|
||||
if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eMbQpDiffWraparound )
|
||||
result += "MbQpDiffWraparound | ";
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
@@ -2336,6 +2359,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
result += "MultipleTilesPerSliceSegment | ";
|
||||
if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eMultipleSliceSegmentsPerTile )
|
||||
result += "MultipleSliceSegmentsPerTile | ";
|
||||
if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eCuQpDiffWraparound )
|
||||
result += "CuQpDiffWraparound | ";
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
@@ -2915,9 +2940,18 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
//=== 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 "{}";
|
||||
|
||||
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 )
|
||||
@@ -2930,6 +2964,13 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
result += "PrecedingExternallyEncodedBytes | ";
|
||||
if ( value & VideoEncodeCapabilityFlagBitsKHR::eInsufficientBitstreamBufferRangeDetection )
|
||||
result += "InsufficientBitstreamBufferRangeDetection | ";
|
||||
<<<<<<< HEAD
|
||||
=======
|
||||
if ( value & VideoEncodeCapabilityFlagBitsKHR::eQuantizationDeltaMap )
|
||||
result += "QuantizationDeltaMap | ";
|
||||
if ( value & VideoEncodeCapabilityFlagBitsKHR::eEmphasisMap )
|
||||
result += "EmphasisMap | ";
|
||||
>>>>>>> indev
|
||||
|
||||
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
|
||||
}
|
||||
@@ -3549,6 +3590,81 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
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 ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( IndirectCommandsLayoutUsageFlagsEXT value )
|
||||
@@ -3935,6 +4051,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case StructureType::eCuModuleCreateInfoNVX: return "CuModuleCreateInfoNVX";
|
||||
case StructureType::eCuFunctionCreateInfoNVX: return "CuFunctionCreateInfoNVX";
|
||||
case StructureType::eCuLaunchInfoNVX: return "CuLaunchInfoNVX";
|
||||
case StructureType::eCuModuleTexturingModeCreateInfoNVX: return "CuModuleTexturingModeCreateInfoNVX";
|
||||
case StructureType::eImageViewHandleInfoNVX: return "ImageViewHandleInfoNVX";
|
||||
case StructureType::eImageViewAddressPropertiesNVX: return "ImageViewAddressPropertiesNVX";
|
||||
case StructureType::eVideoEncodeH264CapabilitiesKHR: return "VideoEncodeH264CapabilitiesKHR";
|
||||
@@ -4582,6 +4699,17 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case StructureType::eVideoDecodeAv1ProfileInfoKHR: return "VideoDecodeAv1ProfileInfoKHR";
|
||||
case StructureType::eVideoDecodeAv1SessionParametersCreateInfoKHR: return "VideoDecodeAv1SessionParametersCreateInfoKHR";
|
||||
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::eVideoInlineQueryInfoKHR: return "VideoInlineQueryInfoKHR";
|
||||
case StructureType::ePhysicalDevicePerStageDescriptorSetFeaturesNV: return "PhysicalDevicePerStageDescriptorSetFeaturesNV";
|
||||
@@ -4623,6 +4751,18 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case StructureType::eSetDescriptorBufferOffsetsInfoEXT: return "SetDescriptorBufferOffsetsInfoEXT";
|
||||
case StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT: return "BindDescriptorBufferEmbeddedSamplersInfoEXT";
|
||||
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::ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR: return "PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR";
|
||||
case StructureType::ePhysicalDeviceCommandBufferInheritanceFeaturesNV: return "PhysicalDeviceCommandBufferInheritanceFeaturesNV";
|
||||
@@ -4658,6 +4798,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case StructureType::ePhysicalDeviceCooperativeMatrix2FeaturesNV: return "PhysicalDeviceCooperativeMatrix2FeaturesNV";
|
||||
case StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV: return "CooperativeMatrixFlexibleDimensionsPropertiesNV";
|
||||
case StructureType::ePhysicalDeviceCooperativeMatrix2PropertiesNV: return "PhysicalDeviceCooperativeMatrix2PropertiesNV";
|
||||
<<<<<<< HEAD
|
||||
=======
|
||||
case StructureType::ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT: return "PhysicalDeviceVertexAttributeRobustnessFeaturesEXT";
|
||||
>>>>>>> indev
|
||||
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::eSampleWeightQCOM: return "SampleWeightQCOM";
|
||||
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 ) ) + " )";
|
||||
}
|
||||
}
|
||||
@@ -5517,6 +5663,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case ImageLayout::eVideoEncodeSrcKHR: return "VideoEncodeSrcKHR";
|
||||
case ImageLayout::eVideoEncodeDpbKHR: return "VideoEncodeDpbKHR";
|
||||
case ImageLayout::eAttachmentFeedbackLoopOptimalEXT: return "AttachmentFeedbackLoopOptimalEXT";
|
||||
case ImageLayout::eVideoEncodeQuantizationMapKHR: return "VideoEncodeQuantizationMapKHR";
|
||||
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::eOpticalFlowVectorNV: return "OpticalFlowVectorNV";
|
||||
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 ) ) + " )";
|
||||
}
|
||||
}
|
||||
@@ -7152,6 +7301,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case VideoCodecOperationFlagBitsKHR::eDecodeH264: return "DecodeH264";
|
||||
case VideoCodecOperationFlagBitsKHR::eDecodeH265: return "DecodeH265";
|
||||
case VideoCodecOperationFlagBitsKHR::eDecodeAv1: return "DecodeAv1";
|
||||
case VideoCodecOperationFlagBitsKHR::eEncodeAv1: return "EncodeAv1";
|
||||
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::eAllowEncodeParameterOptimizations: return "AllowEncodeParameterOptimizations";
|
||||
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 ) ) + " )";
|
||||
}
|
||||
}
|
||||
@@ -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 )
|
||||
@@ -7291,6 +7447,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case VideoEncodeH264CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp: return "PerPictureTypeMinMaxQp";
|
||||
case VideoEncodeH264CapabilityFlagBitsKHR::ePerSliceConstantQp: return "PerSliceConstantQp";
|
||||
case VideoEncodeH264CapabilityFlagBitsKHR::eGeneratePrefixNalu: return "GeneratePrefixNalu";
|
||||
case VideoEncodeH264CapabilityFlagBitsKHR::eMbQpDiffWraparound: return "MbQpDiffWraparound";
|
||||
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::eMultipleTilesPerSliceSegment: return "MultipleTilesPerSliceSegment";
|
||||
case VideoEncodeH265CapabilityFlagBitsKHR::eMultipleSliceSegmentsPerTile: return "MultipleSliceSegmentsPerTile";
|
||||
case VideoEncodeH265CapabilityFlagBitsKHR::eCuQpDiffWraparound: return "CuQpDiffWraparound";
|
||||
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::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 ) ) + " )";
|
||||
}
|
||||
}
|
||||
@@ -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 )
|
||||
@@ -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 ===
|
||||
|
||||
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 ===
|
||||
|
||||
VULKAN_HPP_INLINE std::string to_string( PhysicalDeviceLayeredApiKHR value )
|
||||
|
||||
@@ -73,29 +73,88 @@
|
||||
...
|
||||
}
|
||||
{
|
||||
name
|
||||
memcheck_malloc_suppressions
|
||||
Memcheck:Leak
|
||||
fun:*
|
||||
obj:*
|
||||
fun:malloc
|
||||
...
|
||||
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
|
||||
Memcheck:Leak
|
||||
fun:*
|
||||
obj:*
|
||||
...
|
||||
fun:dl_*
|
||||
...
|
||||
}
|
||||
{
|
||||
name
|
||||
dl_catch_exception_suppressions_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*
|
||||
...
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user