From 7b9ee3d49fe56304f67511c51d8b055bc31d1f85 Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Fri, 2 Feb 2024 01:03:21 +0000 Subject: [PATCH 1/6] [BOT] update dependencies --- .../vk_video/vulkan_video_codec_av1std.h | 392 ++++++++++++ .../vulkan_video_codec_av1std_decode.h | 109 ++++ third_party/vulkan/vulkan.cppm | 12 + third_party/vulkan/vulkan.hpp | 68 +- third_party/vulkan/vulkan_core.h | 57 +- third_party/vulkan/vulkan_enums.hpp | 32 +- .../vulkan/vulkan_extension_inspection.hpp | 23 +- third_party/vulkan/vulkan_handles.hpp | 7 + third_party/vulkan/vulkan_hash.hpp | 75 +++ .../vulkan/vulkan_static_assertions.hpp | 34 + third_party/vulkan/vulkan_structs.hpp | 595 ++++++++++++++++++ third_party/vulkan/vulkan_to_string.hpp | 14 + 12 files changed, 1396 insertions(+), 22 deletions(-) create mode 100644 third_party/vk_video/vulkan_video_codec_av1std.h create mode 100644 third_party/vk_video/vulkan_video_codec_av1std_decode.h diff --git a/third_party/vk_video/vulkan_video_codec_av1std.h b/third_party/vk_video/vulkan_video_codec_av1std.h new file mode 100644 index 0000000..8ce283e --- /dev/null +++ b/third_party/vk_video/vulkan_video_codec_av1std.h @@ -0,0 +1,392 @@ +#ifndef VULKAN_VIDEO_CODEC_AV1STD_H_ +#define VULKAN_VIDEO_CODEC_AV1STD_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 is a preprocessor guard. Do not pass it to API calls. +#define vulkan_video_codec_av1std 1 +#include "vulkan_video_codecs_common.h" +#define STD_VIDEO_AV1_NUM_REF_FRAMES 8 +#define STD_VIDEO_AV1_REFS_PER_FRAME 7 +#define STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME 8 +#define STD_VIDEO_AV1_MAX_TILE_COLS 64 +#define STD_VIDEO_AV1_MAX_TILE_ROWS 64 +#define STD_VIDEO_AV1_MAX_SEGMENTS 8 +#define STD_VIDEO_AV1_SEG_LVL_MAX 8 +#define STD_VIDEO_AV1_PRIMARY_REF_NONE 7 +#define STD_VIDEO_AV1_SELECT_INTEGER_MV 2 +#define STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS 2 +#define STD_VIDEO_AV1_SKIP_MODE_FRAMES 2 +#define STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS 4 +#define STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS 2 +#define STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS 8 +#define STD_VIDEO_AV1_MAX_NUM_PLANES 3 +#define STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS 6 +#define STD_VIDEO_AV1_MAX_NUM_Y_POINTS 14 +#define STD_VIDEO_AV1_MAX_NUM_CB_POINTS 10 +#define STD_VIDEO_AV1_MAX_NUM_CR_POINTS 10 +#define STD_VIDEO_AV1_MAX_NUM_POS_LUMA 24 +#define STD_VIDEO_AV1_MAX_NUM_POS_CHROMA 25 + +typedef enum StdVideoAV1Profile { + STD_VIDEO_AV1_PROFILE_MAIN = 0, + STD_VIDEO_AV1_PROFILE_HIGH = 1, + STD_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, + STD_VIDEO_AV1_PROFILE_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_PROFILE_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1Profile; + +typedef enum StdVideoAV1Level { + STD_VIDEO_AV1_LEVEL_2_0 = 0, + STD_VIDEO_AV1_LEVEL_2_1 = 1, + STD_VIDEO_AV1_LEVEL_2_2 = 2, + STD_VIDEO_AV1_LEVEL_2_3 = 3, + STD_VIDEO_AV1_LEVEL_3_0 = 4, + STD_VIDEO_AV1_LEVEL_3_1 = 5, + STD_VIDEO_AV1_LEVEL_3_2 = 6, + STD_VIDEO_AV1_LEVEL_3_3 = 7, + STD_VIDEO_AV1_LEVEL_4_0 = 8, + STD_VIDEO_AV1_LEVEL_4_1 = 9, + STD_VIDEO_AV1_LEVEL_4_2 = 10, + STD_VIDEO_AV1_LEVEL_4_3 = 11, + STD_VIDEO_AV1_LEVEL_5_0 = 12, + STD_VIDEO_AV1_LEVEL_5_1 = 13, + STD_VIDEO_AV1_LEVEL_5_2 = 14, + STD_VIDEO_AV1_LEVEL_5_3 = 15, + STD_VIDEO_AV1_LEVEL_6_0 = 16, + STD_VIDEO_AV1_LEVEL_6_1 = 17, + STD_VIDEO_AV1_LEVEL_6_2 = 18, + STD_VIDEO_AV1_LEVEL_6_3 = 19, + STD_VIDEO_AV1_LEVEL_7_0 = 20, + STD_VIDEO_AV1_LEVEL_7_1 = 21, + STD_VIDEO_AV1_LEVEL_7_2 = 22, + STD_VIDEO_AV1_LEVEL_7_3 = 23, + STD_VIDEO_AV1_LEVEL_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_LEVEL_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1Level; + +typedef enum StdVideoAV1FrameType { + STD_VIDEO_AV1_FRAME_TYPE_KEY = 0, + STD_VIDEO_AV1_FRAME_TYPE_INTER = 1, + STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY = 2, + STD_VIDEO_AV1_FRAME_TYPE_SWITCH = 3, + STD_VIDEO_AV1_FRAME_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_FRAME_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1FrameType; + +typedef enum StdVideoAV1ReferenceName { + STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME = 0, + STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME = 1, + STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME = 2, + STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME = 3, + STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME = 4, + STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME = 5, + STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME = 6, + STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME = 7, + STD_VIDEO_AV1_REFERENCE_NAME_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_REFERENCE_NAME_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1ReferenceName; + +typedef enum StdVideoAV1InterpolationFilter { + STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, + STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, + STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, + STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR = 3, + STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, + STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_INTERPOLATION_FILTER_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1InterpolationFilter; + +typedef enum StdVideoAV1TxMode { + STD_VIDEO_AV1_TX_MODE_ONLY_4X4 = 0, + STD_VIDEO_AV1_TX_MODE_LARGEST = 1, + STD_VIDEO_AV1_TX_MODE_SELECT = 2, + STD_VIDEO_AV1_TX_MODE_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_TX_MODE_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1TxMode; + +typedef enum StdVideoAV1FrameRestorationType { + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE = 0, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER = 1, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ = 2, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE = 3, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} 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_BT_470_M = 4, + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G = 5, + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601 = 6, + STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240 = 7, + STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM = 8, + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020 = 9, + STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ = 10, + STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431 = 11, + 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_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1ColorPrimaries; + +typedef enum StdVideoAV1TransferCharacteristics { + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0 = 0, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709 = 1, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED = 2, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3 = 3, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M = 4, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G = 5, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601 = 6, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240 = 7, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR = 8, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100 = 9, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10 = 10, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966 = 11, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361 = 12, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB = 13, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT = 14, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT = 15, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084 = 16, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428 = 17, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG = 18, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1TransferCharacteristics; + +typedef enum StdVideoAV1MatrixCoefficients { + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY = 0, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709 = 1, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED = 2, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3 = 3, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC = 4, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G = 5, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601 = 6, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240 = 7, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO = 8, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL = 9, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL = 10, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085 = 11, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL = 12, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL = 13, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP = 14, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1MatrixCoefficients; + +typedef enum StdVideoAV1ChromaSamplePosition { + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN = 0, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL = 1, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED = 2, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED = 3, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1ChromaSamplePosition; +typedef struct StdVideoAV1ColorConfigFlags { + uint32_t mono_chrome : 1; + uint32_t color_range : 1; + uint32_t separate_uv_delta_q : 1; + uint32_t color_description_present_flag : 1; + uint32_t reserved : 28; +} StdVideoAV1ColorConfigFlags; + +typedef struct StdVideoAV1ColorConfig { + StdVideoAV1ColorConfigFlags flags; + uint8_t BitDepth; + uint8_t subsampling_x; + uint8_t subsampling_y; + uint8_t reserved1; + StdVideoAV1ColorPrimaries color_primaries; + StdVideoAV1TransferCharacteristics transfer_characteristics; + StdVideoAV1MatrixCoefficients matrix_coefficients; + StdVideoAV1ChromaSamplePosition chroma_sample_position; +} StdVideoAV1ColorConfig; + +typedef struct StdVideoAV1TimingInfoFlags { + uint32_t equal_picture_interval : 1; + uint32_t reserved : 31; +} StdVideoAV1TimingInfoFlags; + +typedef struct StdVideoAV1TimingInfo { + StdVideoAV1TimingInfoFlags flags; + uint32_t num_units_in_display_tick; + uint32_t time_scale; + uint32_t num_ticks_per_picture_minus_1; +} StdVideoAV1TimingInfo; + +typedef struct StdVideoAV1LoopFilterFlags { + uint32_t loop_filter_delta_enabled : 1; + uint32_t loop_filter_delta_update : 1; + uint32_t reserved : 30; +} StdVideoAV1LoopFilterFlags; + +typedef struct StdVideoAV1LoopFilter { + StdVideoAV1LoopFilterFlags flags; + uint8_t loop_filter_level[STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS]; + uint8_t loop_filter_sharpness; + uint8_t update_ref_delta; + int8_t loop_filter_ref_deltas[STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME]; + uint8_t update_mode_delta; + int8_t loop_filter_mode_deltas[STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS]; +} StdVideoAV1LoopFilter; + +typedef struct StdVideoAV1QuantizationFlags { + uint32_t using_qmatrix : 1; + uint32_t diff_uv_delta : 1; + uint32_t reserved : 30; +} StdVideoAV1QuantizationFlags; + +typedef struct StdVideoAV1Quantization { + StdVideoAV1QuantizationFlags flags; + uint8_t base_q_idx; + int8_t DeltaQYDc; + int8_t DeltaQUDc; + int8_t DeltaQUAc; + int8_t DeltaQVDc; + int8_t DeltaQVAc; + uint8_t qm_y; + uint8_t qm_u; + uint8_t qm_v; +} StdVideoAV1Quantization; + +typedef struct StdVideoAV1Segmentation { + uint8_t FeatureEnabled[STD_VIDEO_AV1_MAX_SEGMENTS]; + int16_t FeatureData[STD_VIDEO_AV1_MAX_SEGMENTS][STD_VIDEO_AV1_SEG_LVL_MAX]; +} StdVideoAV1Segmentation; + +typedef struct StdVideoAV1TileInfoFlags { + uint32_t uniform_tile_spacing_flag : 1; + uint32_t reserved : 31; +} StdVideoAV1TileInfoFlags; + +typedef struct StdVideoAV1TileInfo { + StdVideoAV1TileInfoFlags flags; + uint8_t TileCols; + uint8_t TileRows; + uint16_t context_update_tile_id; + uint8_t tile_size_bytes_minus_1; + uint8_t reserved1[7]; + const uint16_t* pMiColStarts; + const uint16_t* pMiRowStarts; + const uint16_t* pWidthInSbsMinus1; + const uint16_t* pHeightInSbsMinus1; +} StdVideoAV1TileInfo; + +typedef struct StdVideoAV1CDEF { + uint8_t cdef_damping_minus_3; + uint8_t cdef_bits; + uint8_t cdef_y_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; + uint8_t cdef_y_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; + uint8_t cdef_uv_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; + uint8_t cdef_uv_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; +} StdVideoAV1CDEF; + +typedef struct StdVideoAV1LoopRestoration { + StdVideoAV1FrameRestorationType FrameRestorationType[STD_VIDEO_AV1_MAX_NUM_PLANES]; + uint16_t LoopRestorationSize[STD_VIDEO_AV1_MAX_NUM_PLANES]; +} StdVideoAV1LoopRestoration; + +typedef struct StdVideoAV1GlobalMotion { + uint8_t GmType[STD_VIDEO_AV1_NUM_REF_FRAMES]; + int32_t gm_params[STD_VIDEO_AV1_NUM_REF_FRAMES][STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS]; +} StdVideoAV1GlobalMotion; + +typedef struct StdVideoAV1FilmGrainFlags { + uint32_t chroma_scaling_from_luma : 1; + uint32_t overlap_flag : 1; + uint32_t clip_to_restricted_range : 1; + uint32_t update_grain : 1; + uint32_t reserved : 28; +} StdVideoAV1FilmGrainFlags; + +typedef struct StdVideoAV1FilmGrain { + StdVideoAV1FilmGrainFlags flags; + uint8_t grain_scaling_minus_8; + uint8_t ar_coeff_lag; + uint8_t ar_coeff_shift_minus_6; + uint8_t grain_scale_shift; + uint16_t grain_seed; + uint8_t film_grain_params_ref_idx; + uint8_t num_y_points; + uint8_t point_y_value[STD_VIDEO_AV1_MAX_NUM_Y_POINTS]; + uint8_t point_y_scaling[STD_VIDEO_AV1_MAX_NUM_Y_POINTS]; + uint8_t num_cb_points; + uint8_t point_cb_value[STD_VIDEO_AV1_MAX_NUM_CB_POINTS]; + uint8_t point_cb_scaling[STD_VIDEO_AV1_MAX_NUM_CB_POINTS]; + uint8_t num_cr_points; + uint8_t point_cr_value[STD_VIDEO_AV1_MAX_NUM_CR_POINTS]; + uint8_t point_cr_scaling[STD_VIDEO_AV1_MAX_NUM_CR_POINTS]; + int8_t ar_coeffs_y_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_LUMA]; + int8_t ar_coeffs_cb_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA]; + int8_t ar_coeffs_cr_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA]; + uint8_t cb_mult; + uint8_t cb_luma_mult; + uint16_t cb_offset; + uint8_t cr_mult; + uint8_t cr_luma_mult; + uint16_t cr_offset; +} StdVideoAV1FilmGrain; + +typedef struct StdVideoAV1SequenceHeaderFlags { + uint32_t still_picture : 1; + uint32_t reduced_still_picture_header : 1; + uint32_t use_128x128_superblock : 1; + uint32_t enable_filter_intra : 1; + uint32_t enable_intra_edge_filter : 1; + uint32_t enable_interintra_compound : 1; + uint32_t enable_masked_compound : 1; + uint32_t enable_warped_motion : 1; + uint32_t enable_dual_filter : 1; + uint32_t enable_order_hint : 1; + uint32_t enable_jnt_comp : 1; + uint32_t enable_ref_frame_mvs : 1; + uint32_t frame_id_numbers_present_flag : 1; + uint32_t enable_superres : 1; + uint32_t enable_cdef : 1; + uint32_t enable_restoration : 1; + uint32_t film_grain_params_present : 1; + uint32_t timing_info_present_flag : 1; + uint32_t initial_display_delay_present_flag : 1; + uint32_t reserved : 13; +} StdVideoAV1SequenceHeaderFlags; + +typedef struct StdVideoAV1SequenceHeader { + StdVideoAV1SequenceHeaderFlags flags; + StdVideoAV1Profile seq_profile; + uint8_t frame_width_bits_minus_1; + uint8_t frame_height_bits_minus_1; + uint16_t max_frame_width_minus_1; + uint16_t max_frame_height_minus_1; + uint8_t delta_frame_id_length_minus_2; + uint8_t additional_frame_id_length_minus_1; + uint8_t order_hint_bits_minus_1; + uint8_t seq_force_integer_mv; + uint8_t seq_force_screen_content_tools; + uint8_t reserved1[5]; + const StdVideoAV1ColorConfig* pColorConfig; + const StdVideoAV1TimingInfo* pTimingInfo; +} StdVideoAV1SequenceHeader; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/third_party/vk_video/vulkan_video_codec_av1std_decode.h b/third_party/vk_video/vulkan_video_codec_av1std_decode.h new file mode 100644 index 0000000..6b8130c --- /dev/null +++ b/third_party/vk_video/vulkan_video_codec_av1std_decode.h @@ -0,0 +1,109 @@ +#ifndef VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ +#define VULKAN_VIDEO_CODEC_AV1STD_DECODE_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_decode is a preprocessor guard. Do not pass it to API calls. +#define vulkan_video_codec_av1std_decode 1 +#include "vulkan_video_codec_av1std.h" + +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) + +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_av1_decode" +typedef struct StdVideoDecodeAV1PictureInfoFlags { + 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 reference_select : 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 apply_grain : 1; + uint32_t reserved : 3; +} StdVideoDecodeAV1PictureInfoFlags; + +typedef struct StdVideoDecodeAV1PictureInfo { + StdVideoDecodeAV1PictureInfoFlags flags; + StdVideoAV1FrameType frame_type; + uint32_t current_frame_id; + uint8_t OrderHint; + uint8_t primary_ref_frame; + uint8_t refresh_frame_flags; + uint8_t reserved1; + StdVideoAV1InterpolationFilter interpolation_filter; + StdVideoAV1TxMode TxMode; + uint8_t delta_q_res; + uint8_t delta_lf_res; + uint8_t SkipModeFrame[STD_VIDEO_AV1_SKIP_MODE_FRAMES]; + uint8_t coded_denom; + uint8_t reserved2[3]; + uint8_t OrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES]; + uint32_t expectedFrameId[STD_VIDEO_AV1_NUM_REF_FRAMES]; + const StdVideoAV1TileInfo* pTileInfo; + const StdVideoAV1Quantization* pQuantization; + const StdVideoAV1Segmentation* pSegmentation; + const StdVideoAV1LoopFilter* pLoopFilter; + const StdVideoAV1CDEF* pCDEF; + const StdVideoAV1LoopRestoration* pLoopRestoration; + const StdVideoAV1GlobalMotion* pGlobalMotion; + const StdVideoAV1FilmGrain* pFilmGrain; +} StdVideoDecodeAV1PictureInfo; + +typedef struct StdVideoDecodeAV1ReferenceInfoFlags { + uint32_t disable_frame_end_update_cdf : 1; + uint32_t segmentation_enabled : 1; + uint32_t reserved : 30; +} StdVideoDecodeAV1ReferenceInfoFlags; + +typedef struct StdVideoDecodeAV1ReferenceInfo { + StdVideoDecodeAV1ReferenceInfoFlags flags; + uint8_t frame_type; + uint8_t RefFrameSignBias; + uint8_t OrderHint; + uint8_t SavedOrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES]; +} StdVideoDecodeAV1ReferenceInfo; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/third_party/vulkan/vulkan.cppm b/third_party/vulkan/vulkan.cppm index cf3c71f..c24ddce 100644 --- a/third_party/vulkan/vulkan.cppm +++ b/third_party/vulkan/vulkan.cppm @@ -2412,6 +2412,11 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::QCOMMultiviewPerViewRenderAreasExtensionName; using VULKAN_HPP_NAMESPACE::QCOMMultiviewPerViewRenderAreasSpecVersion; + //=== VK_KHR_video_decode_av1 === + using VULKAN_HPP_NAMESPACE::KHRVideoDecodeAv1ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVideoDecodeAv1SpecVersion; + using VULKAN_HPP_NAMESPACE::MaxVideoAv1ReferencesPerFrameKHR; + //=== VK_KHR_video_maintenance1 === using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance1ExtensionName; using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance1SpecVersion; @@ -4227,6 +4232,13 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; + //=== VK_KHR_video_decode_av1 === + using VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR; + //=== VK_KHR_video_maintenance1 === using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR; using VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR; diff --git a/third_party/vulkan/vulkan.hpp b/third_party/vulkan/vulkan.hpp index 23ca0cd..c893919 100644 --- a/third_party/vulkan/vulkan.hpp +++ b/third_party/vulkan/vulkan.hpp @@ -56,7 +56,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h # include #endif -static_assert( VK_HEADER_VERSION == 276, "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 277, "Wrong VK_HEADER_VERSION!" ); // includes through some other header // this results in major(x) being resolved to gnu_dev_major(x) @@ -6852,6 +6852,9 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_shader_module_identifier === VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxShaderModuleIdentifierSizeEXT = VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; + //=== VK_KHR_video_decode_av1 === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxVideoAv1ReferencesPerFrameKHR = VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; + //======================== //=== CONSTEXPR VALUEs === //======================== @@ -7969,8 +7972,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto KHRBufferDeviceAddressSpecVersion = VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION; //=== VK_EXT_line_rasterization === + VULKAN_HPP_DEPRECATED( "The VK_EXT_line_rasterization extension has been promoted to VK_KHR_line_rasterization." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTLineRasterizationExtensionName = VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTLineRasterizationSpecVersion = VK_EXT_LINE_RASTERIZATION_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_EXT_line_rasterization extension has been promoted to VK_KHR_line_rasterization." ) + VULKAN_HPP_CONSTEXPR_INLINE auto EXTLineRasterizationSpecVersion = VK_EXT_LINE_RASTERIZATION_SPEC_VERSION; //=== VK_EXT_shader_atomic_float === VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloatExtensionName = VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME; @@ -8584,6 +8589,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewRenderAreasExtensionName = VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewRenderAreasSpecVersion = VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION; + //=== VK_KHR_video_decode_av1 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeAv1ExtensionName = VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeAv1SpecVersion = VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION; + //=== VK_KHR_video_maintenance1 === VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance1ExtensionName = VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance1SpecVersion = VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION; @@ -16029,6 +16038,61 @@ namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_KHR_video_decode_av1 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_KHR_video_maintenance1 === template <> struct StructExtends diff --git a/third_party/vulkan/vulkan_core.h b/third_party/vulkan/vulkan_core.h index 10d97d8..a4666ed 100644 --- a/third_party/vulkan/vulkan_core.h +++ b/third_party/vulkan/vulkan_core.h @@ -69,7 +69,7 @@ extern "C" { #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 276 +#define VK_HEADER_VERSION 277 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) @@ -1061,6 +1061,11 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000, VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR = 1000512000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR = 1000512001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR = 1000512003, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000512004, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR = 1000512005, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR = 1000515000, VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR = 1000515001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV = 1000516000, @@ -4938,6 +4943,8 @@ typedef enum VkSubgroupFeatureFlagBits { VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100, + VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR = 0x00000200, + VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR = 0x00000400, VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkSubgroupFeatureFlagBits; typedef VkFlags VkSubgroupFeatureFlags; @@ -7977,6 +7984,7 @@ typedef enum VkVideoCodecOperationFlagBitsKHR { VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR = 0x00020000, VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR = 0x00000001, VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR = 0x00000002, + VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR = 0x00000004, VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkVideoCodecOperationFlagBitsKHR; typedef VkFlags VkVideoCodecOperationFlagsKHR; @@ -11046,7 +11054,7 @@ VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR( // VK_KHR_shader_subgroup_rotate is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_shader_subgroup_rotate 1 -#define VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION 1 +#define VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION 2 #define VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME "VK_KHR_shader_subgroup_rotate" typedef struct VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR { VkStructureType sType; @@ -11325,6 +11333,51 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR #endif +// VK_KHR_video_decode_av1 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_decode_av1 1 +#include "vk_video/vulkan_video_codec_av1std.h" +#include "vk_video/vulkan_video_codec_av1std_decode.h" +#define VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR 7U +#define VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION 1 +#define VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME "VK_KHR_video_decode_av1" +typedef struct VkVideoDecodeAV1ProfileInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoAV1Profile stdProfile; + VkBool32 filmGrainSupport; +} VkVideoDecodeAV1ProfileInfoKHR; + +typedef struct VkVideoDecodeAV1CapabilitiesKHR { + VkStructureType sType; + void* pNext; + StdVideoAV1Level maxLevel; +} VkVideoDecodeAV1CapabilitiesKHR; + +typedef struct VkVideoDecodeAV1SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoAV1SequenceHeader* pStdSequenceHeader; +} VkVideoDecodeAV1SessionParametersCreateInfoKHR; + +typedef struct VkVideoDecodeAV1PictureInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeAV1PictureInfo* pStdPictureInfo; + int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]; + uint32_t frameHeaderOffset; + uint32_t tileCount; + const uint32_t* pTileOffsets; + const uint32_t* pTileSizes; +} VkVideoDecodeAV1PictureInfoKHR; + +typedef struct VkVideoDecodeAV1DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeAV1ReferenceInfo* pStdReferenceInfo; +} VkVideoDecodeAV1DpbSlotInfoKHR; + + + // VK_KHR_video_maintenance1 is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_video_maintenance1 1 #define VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION 1 diff --git a/third_party/vulkan/vulkan_enums.hpp b/third_party/vulkan/vulkan_enums.hpp index b242eff..547553a 100644 --- a/third_party/vulkan/vulkan_enums.hpp +++ b/third_party/vulkan/vulkan_enums.hpp @@ -1372,6 +1372,11 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceCooperativeMatrixPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR, ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM, eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM, + eVideoDecodeAv1CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR, + eVideoDecodeAv1PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR, + eVideoDecodeAv1ProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR, + eVideoDecodeAv1SessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR, + eVideoDecodeAv1DpbSlotInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR, ePhysicalDeviceVideoMaintenance1FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR, eVideoInlineQueryInfoKHR = VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR, ePhysicalDevicePerStageDescriptorSetFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV, @@ -3587,15 +3592,17 @@ namespace VULKAN_HPP_NAMESPACE enum class SubgroupFeatureFlagBits : VkSubgroupFeatureFlags { - eBasic = VK_SUBGROUP_FEATURE_BASIC_BIT, - eVote = VK_SUBGROUP_FEATURE_VOTE_BIT, - eArithmetic = VK_SUBGROUP_FEATURE_ARITHMETIC_BIT, - eBallot = VK_SUBGROUP_FEATURE_BALLOT_BIT, - eShuffle = VK_SUBGROUP_FEATURE_SHUFFLE_BIT, - eShuffleRelative = VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT, - eClustered = VK_SUBGROUP_FEATURE_CLUSTERED_BIT, - eQuad = VK_SUBGROUP_FEATURE_QUAD_BIT, - ePartitionedNV = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV + eBasic = VK_SUBGROUP_FEATURE_BASIC_BIT, + eVote = VK_SUBGROUP_FEATURE_VOTE_BIT, + eArithmetic = VK_SUBGROUP_FEATURE_ARITHMETIC_BIT, + eBallot = VK_SUBGROUP_FEATURE_BALLOT_BIT, + eShuffle = VK_SUBGROUP_FEATURE_SHUFFLE_BIT, + eShuffleRelative = VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT, + eClustered = VK_SUBGROUP_FEATURE_CLUSTERED_BIT, + eQuad = VK_SUBGROUP_FEATURE_QUAD_BIT, + ePartitionedNV = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV, + eRotateKHR = VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR, + eRotateClusteredKHR = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR }; using SubgroupFeatureFlags = Flags; @@ -3607,7 +3614,7 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR SubgroupFeatureFlags allFlags = SubgroupFeatureFlagBits::eBasic | SubgroupFeatureFlagBits::eVote | SubgroupFeatureFlagBits::eArithmetic | SubgroupFeatureFlagBits::eBallot | SubgroupFeatureFlagBits::eShuffle | SubgroupFeatureFlagBits::eShuffleRelative | SubgroupFeatureFlagBits::eClustered | SubgroupFeatureFlagBits::eQuad | - SubgroupFeatureFlagBits::ePartitionedNV; + SubgroupFeatureFlagBits::ePartitionedNV | SubgroupFeatureFlagBits::eRotateKHR | SubgroupFeatureFlagBits::eRotateClusteredKHR; }; enum class PeerMemoryFeatureFlagBits : VkPeerMemoryFeatureFlags @@ -4699,7 +4706,8 @@ namespace VULKAN_HPP_NAMESPACE eEncodeH264 = VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, eEncodeH265 = VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, eDecodeH264 = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, - eDecodeH265 = VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR + eDecodeH265 = VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, + eDecodeAv1 = VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR }; using VideoCodecOperationFlagsKHR = Flags; @@ -4710,7 +4718,7 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoCodecOperationFlagsKHR allFlags = VideoCodecOperationFlagBitsKHR::eNone | VideoCodecOperationFlagBitsKHR::eEncodeH264 | VideoCodecOperationFlagBitsKHR::eEncodeH265 | - VideoCodecOperationFlagBitsKHR::eDecodeH264 | VideoCodecOperationFlagBitsKHR::eDecodeH265; + VideoCodecOperationFlagBitsKHR::eDecodeH264 | VideoCodecOperationFlagBitsKHR::eDecodeH265 | VideoCodecOperationFlagBitsKHR::eDecodeAv1; }; enum class VideoChromaSubsamplingFlagBitsKHR : VkVideoChromaSubsamplingFlagsKHR diff --git a/third_party/vulkan/vulkan_extension_inspection.hpp b/third_party/vulkan/vulkan_extension_inspection.hpp index 100b141..75958da 100644 --- a/third_party/vulkan/vulkan_extension_inspection.hpp +++ b/third_party/vulkan/vulkan_extension_inspection.hpp @@ -412,6 +412,7 @@ namespace VULKAN_HPP_NAMESPACE "VK_NV_low_latency2", "VK_KHR_cooperative_matrix", "VK_QCOM_multiview_per_view_render_areas", + "VK_KHR_video_decode_av1", "VK_KHR_video_maintenance1", "VK_NV_per_stage_descriptor_set", "VK_QCOM_image_processing2", @@ -2010,6 +2011,11 @@ namespace VULKAN_HPP_NAMESPACE { { "VK_KHR_get_physical_device_properties2", } } } } }, + { "VK_KHR_video_decode_av1", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_decode_queue", + } } } } }, { "VK_KHR_video_maintenance1", { { "VK_VERSION_1_0", { { @@ -2205,6 +2211,7 @@ namespace VULKAN_HPP_NAMESPACE { "VK_EXT_separate_stencil_usage", "VK_VERSION_1_2" }, { "VK_KHR_uniform_buffer_standard_layout", "VK_VERSION_1_2" }, { "VK_KHR_buffer_device_address", "VK_VERSION_1_2" }, + { "VK_EXT_line_rasterization", "VK_KHR_line_rasterization" }, { "VK_EXT_host_query_reset", "VK_VERSION_1_2" }, { "VK_EXT_index_type_uint8", "VK_KHR_index_type_uint8" }, { "VK_EXT_extended_dynamic_state", "VK_VERSION_1_3" }, @@ -2559,6 +2566,10 @@ namespace VULKAN_HPP_NAMESPACE { return "VK_VERSION_1_2"; } + if ( extension == "VK_EXT_line_rasterization" ) + { + return "VK_KHR_line_rasterization"; + } if ( extension == "VK_EXT_host_query_reset" ) { return "VK_VERSION_1_2"; @@ -2845,8 +2856,8 @@ namespace VULKAN_HPP_NAMESPACE ( extension == "VK_EXT_mutable_descriptor_type" ) || ( extension == "VK_ARM_shader_core_builtins" ) || ( extension == "VK_EXT_pipeline_library_group_handles" ) || ( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) || ( extension == "VK_NV_low_latency2" ) || ( extension == "VK_KHR_cooperative_matrix" ) || - ( extension == "VK_QCOM_multiview_per_view_render_areas" ) || ( extension == "VK_KHR_video_maintenance1" ) || - ( extension == "VK_NV_per_stage_descriptor_set" ) || ( extension == "VK_QCOM_image_processing2" ) || + ( extension == "VK_QCOM_multiview_per_view_render_areas" ) || ( extension == "VK_KHR_video_decode_av1" ) || + ( extension == "VK_KHR_video_maintenance1" ) || ( extension == "VK_NV_per_stage_descriptor_set" ) || ( extension == "VK_QCOM_image_processing2" ) || ( extension == "VK_QCOM_filter_cubic_weights" ) || ( extension == "VK_QCOM_ycbcr_degamma" ) || ( extension == "VK_QCOM_filter_cubic_clamp" ) || ( extension == "VK_EXT_attachment_feedback_loop_dynamic_state" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) || ( extension == "VK_KHR_load_store_op_none" ) || ( extension == "VK_KHR_shader_float_controls2" ) @@ -2953,10 +2964,10 @@ namespace VULKAN_HPP_NAMESPACE ( 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_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_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" ) || diff --git a/third_party/vulkan/vulkan_handles.hpp b/third_party/vulkan/vulkan_handles.hpp index d1f6ba1..e6b1481 100644 --- a/third_party/vulkan/vulkan_handles.hpp +++ b/third_party/vulkan/vulkan_handles.hpp @@ -1724,6 +1724,13 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; + //=== VK_KHR_video_decode_av1 === + struct VideoDecodeAV1ProfileInfoKHR; + struct VideoDecodeAV1CapabilitiesKHR; + struct VideoDecodeAV1SessionParametersCreateInfoKHR; + struct VideoDecodeAV1PictureInfoKHR; + struct VideoDecodeAV1DpbSlotInfoKHR; + //=== VK_KHR_video_maintenance1 === struct PhysicalDeviceVideoMaintenance1FeaturesKHR; struct VideoInlineQueryInfoKHR; diff --git a/third_party/vulkan/vulkan_hash.hpp b/third_party/vulkan/vulkan_hash.hpp index 91e97fd..bebd7cb 100644 --- a/third_party/vulkan/vulkan_hash.hpp +++ b/third_party/vulkan/vulkan_hash.hpp @@ -15404,6 +15404,81 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR const & videoDecodeAV1CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.maxLevel ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR const & videoDecodeAV1DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.pStdReferenceInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR const & videoDecodeAV1PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pStdPictureInfo ); + for ( size_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.referenceNameSlotIndices[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.frameHeaderOffset ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.tileCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pTileOffsets ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pTileSizes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR const & videoDecodeAV1ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.stdProfile ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.filmGrainSupport ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR const & videoDecodeAV1SessionParametersCreateInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.pStdSequenceHeader ); + return seed; + } + }; + template <> struct hash { diff --git a/third_party/vulkan/vulkan_static_assertions.hpp b/third_party/vulkan/vulkan_static_assertions.hpp index 880d905..30f287a 100644 --- a/third_party/vulkan/vulkan_static_assertions.hpp +++ b/third_party/vulkan/vulkan_static_assertions.hpp @@ -7104,6 +7104,40 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM is not nothrow_move_constructible!" ); +//=== VK_KHR_video_decode_av1 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR ) == sizeof( VkVideoDecodeAV1ProfileInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeAV1ProfileInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR ) == sizeof( VkVideoDecodeAV1CapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeAV1CapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR ) == + sizeof( VkVideoDecodeAV1SessionParametersCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeAV1SessionParametersCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR ) == sizeof( VkVideoDecodeAV1PictureInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeAV1PictureInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR ) == sizeof( VkVideoDecodeAV1DpbSlotInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeAV1DpbSlotInfoKHR is not nothrow_move_constructible!" ); + //=== VK_KHR_video_maintenance1 === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR ) == sizeof( VkPhysicalDeviceVideoMaintenance1FeaturesKHR ), diff --git a/third_party/vulkan/vulkan_structs.hpp b/third_party/vulkan/vulkan_structs.hpp index 6a74e2f..c18fbe9 100644 --- a/third_party/vulkan/vulkan_structs.hpp +++ b/third_party/vulkan/vulkan_structs.hpp @@ -114942,6 +114942,601 @@ namespace VULKAN_HPP_NAMESPACE using Type = VideoCodingControlInfoKHR; }; + struct VideoDecodeAV1CapabilitiesKHR + { + using NativeType = VkVideoDecodeAV1CapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1CapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeAV1CapabilitiesKHR( StdVideoAV1Level maxLevel_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , maxLevel( maxLevel_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeAV1CapabilitiesKHR( VideoDecodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeAV1CapabilitiesKHR( VkVideoDecodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeAV1CapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeAV1CapabilitiesKHR & operator=( VideoDecodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoDecodeAV1CapabilitiesKHR & operator=( VkVideoDecodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoDecodeAV1CapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1CapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxLevel ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoDecodeAV1CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoAV1Level ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoDecodeAV1CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoAV1Level ) ) == 0 ); + } + + bool operator!=( VideoDecodeAV1CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeAv1CapabilitiesKHR; + void * pNext = {}; + StdVideoAV1Level maxLevel = {}; + }; + + template <> + struct CppType + { + using Type = VideoDecodeAV1CapabilitiesKHR; + }; + + struct VideoDecodeAV1DpbSlotInfoKHR + { + using NativeType = VkVideoDecodeAV1DpbSlotInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1DpbSlotInfoKHR; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeAV1DpbSlotInfoKHR( const StdVideoDecodeAV1ReferenceInfo * pStdReferenceInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , pStdReferenceInfo( pStdReferenceInfo_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeAV1DpbSlotInfoKHR( VideoDecodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeAV1DpbSlotInfoKHR( VkVideoDecodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeAV1DpbSlotInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeAV1DpbSlotInfoKHR & operator=( VideoDecodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoDecodeAV1DpbSlotInfoKHR & operator=( VkVideoDecodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1DpbSlotInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1DpbSlotInfoKHR & setPStdReferenceInfo( const StdVideoDecodeAV1ReferenceInfo * pStdReferenceInfo_ ) VULKAN_HPP_NOEXCEPT + { + pStdReferenceInfo = pStdReferenceInfo_; + return *this; + } +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoDecodeAV1DpbSlotInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1DpbSlotInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdReferenceInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeAV1DpbSlotInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeAV1DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); +# endif + } + + bool operator!=( VideoDecodeAV1DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeAv1DpbSlotInfoKHR; + const void * pNext = {}; + const StdVideoDecodeAV1ReferenceInfo * pStdReferenceInfo = {}; + }; + + template <> + struct CppType + { + using Type = VideoDecodeAV1DpbSlotInfoKHR; + }; + + struct VideoDecodeAV1PictureInfoKHR + { + using NativeType = VkVideoDecodeAV1PictureInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1PictureInfoKHR; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR( const StdVideoDecodeAV1PictureInfo * pStdPictureInfo_ = {}, + std::array const & referenceNameSlotIndices_ = {}, + uint32_t frameHeaderOffset_ = {}, + uint32_t tileCount_ = {}, + const uint32_t * pTileOffsets_ = {}, + const uint32_t * pTileSizes_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , pStdPictureInfo( pStdPictureInfo_ ) + , referenceNameSlotIndices( referenceNameSlotIndices_ ) + , frameHeaderOffset( frameHeaderOffset_ ) + , tileCount( tileCount_ ) + , pTileOffsets( pTileOffsets_ ) + , pTileSizes( pTileSizes_ ) + { + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR( VideoDecodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeAV1PictureInfoKHR( VkVideoDecodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeAV1PictureInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeAV1PictureInfoKHR( const StdVideoDecodeAV1PictureInfo * pStdPictureInfo_, + std::array const & referenceNameSlotIndices_, + uint32_t frameHeaderOffset_, + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & tileOffsets_, + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & tileSizes_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , pStdPictureInfo( pStdPictureInfo_ ) + , referenceNameSlotIndices( referenceNameSlotIndices_ ) + , frameHeaderOffset( frameHeaderOffset_ ) + , tileCount( static_cast( tileOffsets_.size() ) ) + , pTileOffsets( tileOffsets_.data() ) + , pTileSizes( tileSizes_.data() ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( tileOffsets_.size() == tileSizes_.size() ); +# else + if ( tileOffsets_.size() != tileSizes_.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::VideoDecodeAV1PictureInfoKHR::VideoDecodeAV1PictureInfoKHR: tileOffsets_.size() != tileSizes_.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoDecodeAV1PictureInfoKHR & operator=( VideoDecodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoDecodeAV1PictureInfoKHR & operator=( VkVideoDecodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setPStdPictureInfo( const StdVideoDecodeAV1PictureInfo * pStdPictureInfo_ ) VULKAN_HPP_NOEXCEPT + { + pStdPictureInfo = pStdPictureInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & + setReferenceNameSlotIndices( std::array referenceNameSlotIndices_ ) VULKAN_HPP_NOEXCEPT + { + referenceNameSlotIndices = referenceNameSlotIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setFrameHeaderOffset( uint32_t frameHeaderOffset_ ) VULKAN_HPP_NOEXCEPT + { + frameHeaderOffset = frameHeaderOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setTileCount( uint32_t tileCount_ ) VULKAN_HPP_NOEXCEPT + { + tileCount = tileCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setPTileOffsets( const uint32_t * pTileOffsets_ ) VULKAN_HPP_NOEXCEPT + { + pTileOffsets = pTileOffsets_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeAV1PictureInfoKHR & setTileOffsets( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & tileOffsets_ ) VULKAN_HPP_NOEXCEPT + { + tileCount = static_cast( tileOffsets_.size() ); + pTileOffsets = tileOffsets_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setPTileSizes( const uint32_t * pTileSizes_ ) VULKAN_HPP_NOEXCEPT + { + pTileSizes = pTileSizes_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeAV1PictureInfoKHR & setTileSizes( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & tileSizes_ ) VULKAN_HPP_NOEXCEPT + { + tileCount = static_cast( tileSizes_.size() ); + pTileSizes = tileSizes_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoDecodeAV1PictureInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1PictureInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple const &, + uint32_t const &, + uint32_t const &, + const uint32_t * const &, + const uint32_t * const &> +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdPictureInfo, referenceNameSlotIndices, frameHeaderOffset, tileCount, pTileOffsets, pTileSizes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeAV1PictureInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeAV1PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && + ( referenceNameSlotIndices == rhs.referenceNameSlotIndices ) && ( frameHeaderOffset == rhs.frameHeaderOffset ) && ( tileCount == rhs.tileCount ) && + ( pTileOffsets == rhs.pTileOffsets ) && ( pTileSizes == rhs.pTileSizes ); +# endif + } + + bool operator!=( VideoDecodeAV1PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeAv1PictureInfoKHR; + const void * pNext = {}; + const StdVideoDecodeAV1PictureInfo * pStdPictureInfo = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D referenceNameSlotIndices = {}; + uint32_t frameHeaderOffset = {}; + uint32_t tileCount = {}; + const uint32_t * pTileOffsets = {}; + const uint32_t * pTileSizes = {}; + }; + + template <> + struct CppType + { + using Type = VideoDecodeAV1PictureInfoKHR; + }; + + struct VideoDecodeAV1ProfileInfoKHR + { + using NativeType = VkVideoDecodeAV1ProfileInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1ProfileInfoKHR; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeAV1ProfileInfoKHR( StdVideoAV1Profile stdProfile_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 filmGrainSupport_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , stdProfile( stdProfile_ ) + , filmGrainSupport( filmGrainSupport_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeAV1ProfileInfoKHR( VideoDecodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeAV1ProfileInfoKHR( VkVideoDecodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeAV1ProfileInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeAV1ProfileInfoKHR & operator=( VideoDecodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoDecodeAV1ProfileInfoKHR & operator=( VkVideoDecodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1ProfileInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1ProfileInfoKHR & setStdProfile( StdVideoAV1Profile stdProfile_ ) VULKAN_HPP_NOEXCEPT + { + stdProfile = stdProfile_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1ProfileInfoKHR & setFilmGrainSupport( VULKAN_HPP_NAMESPACE::Bool32 filmGrainSupport_ ) VULKAN_HPP_NOEXCEPT + { + filmGrainSupport = filmGrainSupport_; + return *this; + } +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoDecodeAV1ProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1ProfileInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdProfile, filmGrainSupport ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoDecodeAV1ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &stdProfile, &rhs.stdProfile, sizeof( StdVideoAV1Profile ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = filmGrainSupport <=> rhs.filmGrainSupport; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoDecodeAV1ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfile, &rhs.stdProfile, sizeof( StdVideoAV1Profile ) ) == 0 ) && + ( filmGrainSupport == rhs.filmGrainSupport ); + } + + bool operator!=( VideoDecodeAV1ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeAv1ProfileInfoKHR; + const void * pNext = {}; + StdVideoAV1Profile stdProfile = {}; + VULKAN_HPP_NAMESPACE::Bool32 filmGrainSupport = {}; + }; + + template <> + struct CppType + { + using Type = VideoDecodeAV1ProfileInfoKHR; + }; + + struct VideoDecodeAV1SessionParametersCreateInfoKHR + { + using NativeType = VkVideoDecodeAV1SessionParametersCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1SessionParametersCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeAV1SessionParametersCreateInfoKHR( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , pStdSequenceHeader( pStdSequenceHeader_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeAV1SessionParametersCreateInfoKHR( VideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeAV1SessionParametersCreateInfoKHR( VkVideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeAV1SessionParametersCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeAV1SessionParametersCreateInfoKHR & operator=( VideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoDecodeAV1SessionParametersCreateInfoKHR & operator=( VkVideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1SessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1SessionParametersCreateInfoKHR & + setPStdSequenceHeader( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ ) VULKAN_HPP_NOEXCEPT + { + pStdSequenceHeader = pStdSequenceHeader_; + return *this; + } +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoDecodeAV1SessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1SessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdSequenceHeader ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeAV1SessionParametersCreateInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdSequenceHeader == rhs.pStdSequenceHeader ); +# endif + } + + bool operator!=( VideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeAv1SessionParametersCreateInfoKHR; + const void * pNext = {}; + const StdVideoAV1SequenceHeader * pStdSequenceHeader = {}; + }; + + template <> + struct CppType + { + using Type = VideoDecodeAV1SessionParametersCreateInfoKHR; + }; + struct VideoDecodeCapabilitiesKHR { using NativeType = VkVideoDecodeCapabilitiesKHR; diff --git a/third_party/vulkan/vulkan_to_string.hpp b/third_party/vulkan/vulkan_to_string.hpp index 80aa4a5..b7c08c7 100644 --- a/third_party/vulkan/vulkan_to_string.hpp +++ b/third_party/vulkan/vulkan_to_string.hpp @@ -1223,6 +1223,10 @@ namespace VULKAN_HPP_NAMESPACE result += "Quad | "; if ( value & SubgroupFeatureFlagBits::ePartitionedNV ) result += "PartitionedNV | "; + if ( value & SubgroupFeatureFlagBits::eRotateKHR ) + result += "RotateKHR | "; + if ( value & SubgroupFeatureFlagBits::eRotateClusteredKHR ) + result += "RotateClusteredKHR | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -2039,6 +2043,8 @@ namespace VULKAN_HPP_NAMESPACE result += "DecodeH264 | "; if ( value & VideoCodecOperationFlagBitsKHR::eDecodeH265 ) result += "DecodeH265 | "; + if ( value & VideoCodecOperationFlagBitsKHR::eDecodeAv1 ) + result += "DecodeAv1 | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -4480,6 +4486,11 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceCooperativeMatrixPropertiesKHR: return "PhysicalDeviceCooperativeMatrixPropertiesKHR"; case StructureType::ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM: return "PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM"; case StructureType::eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM: return "MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM"; + case StructureType::eVideoDecodeAv1CapabilitiesKHR: return "VideoDecodeAv1CapabilitiesKHR"; + case StructureType::eVideoDecodeAv1PictureInfoKHR: return "VideoDecodeAv1PictureInfoKHR"; + case StructureType::eVideoDecodeAv1ProfileInfoKHR: return "VideoDecodeAv1ProfileInfoKHR"; + case StructureType::eVideoDecodeAv1SessionParametersCreateInfoKHR: return "VideoDecodeAv1SessionParametersCreateInfoKHR"; + case StructureType::eVideoDecodeAv1DpbSlotInfoKHR: return "VideoDecodeAv1DpbSlotInfoKHR"; case StructureType::ePhysicalDeviceVideoMaintenance1FeaturesKHR: return "PhysicalDeviceVideoMaintenance1FeaturesKHR"; case StructureType::eVideoInlineQueryInfoKHR: return "VideoInlineQueryInfoKHR"; case StructureType::ePhysicalDevicePerStageDescriptorSetFeaturesNV: return "PhysicalDevicePerStageDescriptorSetFeaturesNV"; @@ -6227,6 +6238,8 @@ namespace VULKAN_HPP_NAMESPACE case SubgroupFeatureFlagBits::eClustered: return "Clustered"; case SubgroupFeatureFlagBits::eQuad: return "Quad"; case SubgroupFeatureFlagBits::ePartitionedNV: return "PartitionedNV"; + case SubgroupFeatureFlagBits::eRotateKHR: return "RotateKHR"; + case SubgroupFeatureFlagBits::eRotateClusteredKHR: return "RotateClusteredKHR"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -7001,6 +7014,7 @@ namespace VULKAN_HPP_NAMESPACE case VideoCodecOperationFlagBitsKHR::eEncodeH265: return "EncodeH265"; case VideoCodecOperationFlagBitsKHR::eDecodeH264: return "DecodeH264"; case VideoCodecOperationFlagBitsKHR::eDecodeH265: return "DecodeH265"; + case VideoCodecOperationFlagBitsKHR::eDecodeAv1: return "DecodeAv1"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } From 3bb167e164034cafcc02083d1f7265a230740e4e Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Sat, 17 Feb 2024 01:02:15 +0000 Subject: [PATCH 2/6] [BOT] update dependencies --- third_party/vulkan/vulkan.cppm | 17 +- third_party/vulkan/vulkan.hpp | 83 +- third_party/vulkan/vulkan_core.h | 61 +- third_party/vulkan/vulkan_enums.hpp | 13 +- .../vulkan/vulkan_extension_inspection.hpp | 28 +- third_party/vulkan/vulkan_funcs.hpp | 647 ++++---- third_party/vulkan/vulkan_handles.hpp | 74 +- third_party/vulkan/vulkan_hash.hpp | 57 + third_party/vulkan/vulkan_raii.hpp | 121 +- .../vulkan/vulkan_static_assertions.hpp | 32 + third_party/vulkan/vulkan_structs.hpp | 1478 ++++++++++++++--- third_party/vulkan/vulkan_to_string.hpp | 44 +- third_party/vulkan/vulkan_video.hpp | 1016 ++++++++++- 13 files changed, 2985 insertions(+), 686 deletions(-) diff --git a/third_party/vulkan/vulkan.cppm b/third_party/vulkan/vulkan.cppm index c24ddce..a408a68 100644 --- a/third_party/vulkan/vulkan.cppm +++ b/third_party/vulkan/vulkan.cppm @@ -905,7 +905,6 @@ export namespace VULKAN_HPP_NAMESPACE # endif /*VK_USE_PLATFORM_WIN32_KHR*/ using VULKAN_HPP_NAMESPACE::CompressionExhaustedEXTError; - using VULKAN_HPP_NAMESPACE::IncompatibleShaderBinaryEXTError; using VULKAN_HPP_NAMESPACE::InvalidVideoStdParametersKHRError; #endif /*VULKAN_HPP_NO_EXCEPTIONS*/ @@ -1873,6 +1872,10 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::KHRMapMemory2ExtensionName; using VULKAN_HPP_NAMESPACE::KHRMapMemory2SpecVersion; + //=== VK_EXT_map_memory_placed === + using VULKAN_HPP_NAMESPACE::EXTMapMemoryPlacedExtensionName; + using VULKAN_HPP_NAMESPACE::EXTMapMemoryPlacedSpecVersion; + //=== VK_EXT_shader_atomic_float2 === using VULKAN_HPP_NAMESPACE::EXTShaderAtomicFloat2ExtensionName; using VULKAN_HPP_NAMESPACE::EXTShaderAtomicFloat2SpecVersion; @@ -2491,6 +2494,10 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationExtensionName; using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationSpecVersion; + //=== VK_NV_shader_atomic_float16_vector === + using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorExtensionName; + using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorSpecVersion; + //======================== //=== CONSTEXPR VALUEs === //======================== @@ -3671,6 +3678,11 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR; using VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR; + //=== VK_EXT_map_memory_placed === + using VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT; + //=== VK_EXT_shader_atomic_float2 === using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT; @@ -4323,6 +4335,9 @@ export namespace VULKAN_HPP_NAMESPACE //=== VK_NV_descriptor_pool_overallocation === using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV; + //=== VK_NV_shader_atomic_float16_vector === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; + //=============== //=== HANDLEs === //=============== diff --git a/third_party/vulkan/vulkan.hpp b/third_party/vulkan/vulkan.hpp index c893919..e9babb5 100644 --- a/third_party/vulkan/vulkan.hpp +++ b/third_party/vulkan/vulkan.hpp @@ -56,7 +56,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h # include #endif -static_assert( VK_HEADER_VERSION == 277, "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 278, "Wrong VK_HEADER_VERSION!" ); // includes through some other header // this results in major(x) being resolved to gnu_dev_major(x) @@ -723,10 +723,10 @@ namespace VULKAN_HPP_NAMESPACE template >::type, size_t Which = 0> StructureChain & assign( const T & rhs ) VULKAN_HPP_NOEXCEPT { - T & lhs = get(); - void * pNext = lhs.pNext; - lhs = rhs; - lhs.pNext = pNext; + T & lhs = get(); + auto pNext = lhs.pNext; + lhs = rhs; + lhs.pNext = pNext; return *this; } @@ -6549,14 +6549,6 @@ namespace VULKAN_HPP_NAMESPACE CompressionExhaustedEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {} }; - class IncompatibleShaderBinaryEXTError : public SystemError - { - public: - IncompatibleShaderBinaryEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorIncompatibleShaderBinaryEXT ), message ) {} - - IncompatibleShaderBinaryEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorIncompatibleShaderBinaryEXT ), message ) {} - }; - namespace detail { [[noreturn]] VULKAN_HPP_INLINE void throwResultException( Result result, char const * message ) @@ -6599,7 +6591,6 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VK_USE_PLATFORM_WIN32_KHR*/ case Result::eErrorInvalidVideoStdParametersKHR: throw InvalidVideoStdParametersKHRError( message ); case Result::eErrorCompressionExhaustedEXT: throw CompressionExhaustedEXTError( message ); - case Result::eErrorIncompatibleShaderBinaryEXT: throw IncompatibleShaderBinaryEXTError( message ); default: throw SystemError( make_error_code( result ), message ); } } @@ -8015,6 +8006,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto KHRMapMemory2ExtensionName = VK_KHR_MAP_MEMORY_2_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto KHRMapMemory2SpecVersion = VK_KHR_MAP_MEMORY_2_SPEC_VERSION; + //=== VK_EXT_map_memory_placed === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMapMemoryPlacedExtensionName = VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMapMemoryPlacedSpecVersion = VK_EXT_MAP_MEMORY_PLACED_SPEC_VERSION; + //=== VK_EXT_shader_atomic_float2 === VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloat2ExtensionName = VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloat2SpecVersion = VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION; @@ -8667,6 +8662,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto NVDescriptorPoolOverallocationExtensionName = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto NVDescriptorPoolOverallocationSpecVersion = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION; + //=== VK_NV_shader_atomic_float16_vector === + VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorExtensionName = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME; + VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorSpecVersion = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION; + } // namespace VULKAN_HPP_NAMESPACE // clang-format off @@ -12833,6 +12832,43 @@ namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_EXT_map_memory_placed === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_EXT_shader_atomic_float2 === template <> struct StructExtends @@ -16552,6 +16588,25 @@ namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_NV_shader_atomic_float16_vector === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + #endif // VULKAN_HPP_DISABLE_ENHANCED_MODE #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL diff --git a/third_party/vulkan/vulkan_core.h b/third_party/vulkan/vulkan_core.h index a4666ed..7e6b040 100644 --- a/third_party/vulkan/vulkan_core.h +++ b/third_party/vulkan/vulkan_core.h @@ -69,7 +69,7 @@ extern "C" { #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 277 +#define VK_HEADER_VERSION 278 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) @@ -184,7 +184,7 @@ typedef enum VkResult { VK_OPERATION_NOT_DEFERRED_KHR = 1000268003, VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR = -1000299000, VK_ERROR_COMPRESSION_EXHAUSTED_EXT = -1000338000, - VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000, + VK_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000, VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION, @@ -193,6 +193,7 @@ typedef enum VkResult { VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, VK_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED, VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED, + VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT = VK_INCOMPATIBLE_SHADER_BINARY_EXT, VK_RESULT_MAX_ENUM = 0x7FFFFFFF } VkResult; @@ -767,6 +768,9 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT = 1000270009, VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR = 1000271000, VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR = 1000271001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT = 1000272000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT = 1000272001, + VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT = 1000272002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000, VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT = 1000274000, VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT = 1000274001, @@ -1105,6 +1109,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT = 1000545007, VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT = 1000545008, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, @@ -2424,6 +2429,11 @@ typedef enum VkPipelineStageFlagBits { VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkPipelineStageFlagBits; typedef VkFlags VkPipelineStageFlags; + +typedef enum VkMemoryMapFlagBits { + VK_MEMORY_MAP_PLACED_BIT_EXT = 0x00000001, + VK_MEMORY_MAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryMapFlagBits; typedef VkFlags VkMemoryMapFlags; typedef enum VkSparseMemoryBindFlagBits { @@ -10495,6 +10505,11 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR #define VK_KHR_map_memory2 1 #define VK_KHR_MAP_MEMORY_2_SPEC_VERSION 1 #define VK_KHR_MAP_MEMORY_2_EXTENSION_NAME "VK_KHR_map_memory2" + +typedef enum VkMemoryUnmapFlagBitsKHR { + VK_MEMORY_UNMAP_RESERVE_BIT_EXT = 0x00000001, + VK_MEMORY_UNMAP_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkMemoryUnmapFlagBitsKHR; typedef VkFlags VkMemoryUnmapFlagsKHR; typedef struct VkMemoryMapInfoKHR { VkStructureType sType; @@ -10588,6 +10603,10 @@ typedef enum VkVideoEncodeTuningModeKHR { VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR = 4, VK_VIDEO_ENCODE_TUNING_MODE_MAX_ENUM_KHR = 0x7FFFFFFF } VkVideoEncodeTuningModeKHR; + +typedef enum VkVideoEncodeFlagBitsKHR { + VK_VIDEO_ENCODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeFlagBitsKHR; typedef VkFlags VkVideoEncodeFlagsKHR; typedef enum VkVideoEncodeCapabilityFlagBitsKHR { @@ -15182,6 +15201,32 @@ VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2EXT( #endif +// VK_EXT_map_memory_placed is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_map_memory_placed 1 +#define VK_EXT_MAP_MEMORY_PLACED_SPEC_VERSION 1 +#define VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME "VK_EXT_map_memory_placed" +typedef struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 memoryMapPlaced; + VkBool32 memoryMapRangePlaced; + VkBool32 memoryUnmapReserve; +} VkPhysicalDeviceMapMemoryPlacedFeaturesEXT; + +typedef struct VkPhysicalDeviceMapMemoryPlacedPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize minPlacedMemoryMapAlignment; +} VkPhysicalDeviceMapMemoryPlacedPropertiesEXT; + +typedef struct VkMemoryMapPlacedInfoEXT { + VkStructureType sType; + const void* pNext; + void* pPlacedAddress; +} VkMemoryMapPlacedInfoEXT; + + + // VK_EXT_shader_atomic_float2 is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_shader_atomic_float2 1 #define VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION 1 @@ -19068,6 +19113,18 @@ typedef struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV { +// VK_NV_shader_atomic_float16_vector is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_shader_atomic_float16_vector 1 +#define VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION 1 +#define VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME "VK_NV_shader_atomic_float16_vector" +typedef struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 shaderFloat16VectorAtomics; +} VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; + + + // VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_acceleration_structure 1 #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13 diff --git a/third_party/vulkan/vulkan_enums.hpp b/third_party/vulkan/vulkan_enums.hpp index 547553a..2ddc619 100644 --- a/third_party/vulkan/vulkan_enums.hpp +++ b/third_party/vulkan/vulkan_enums.hpp @@ -285,6 +285,7 @@ namespace VULKAN_HPP_NAMESPACE eErrorPipelineCompileRequiredEXT = VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT, eErrorInvalidVideoStdParametersKHR = VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR, eErrorCompressionExhaustedEXT = VK_ERROR_COMPRESSION_EXHAUSTED_EXT, + eIncompatibleShaderBinaryEXT = VK_INCOMPATIBLE_SHADER_BINARY_EXT, eErrorIncompatibleShaderBinaryEXT = VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT }; @@ -1027,6 +1028,9 @@ namespace VULKAN_HPP_NAMESPACE eHostImageCopyDevicePerformanceQueryEXT = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT, eMemoryMapInfoKHR = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR, eMemoryUnmapInfoKHR = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR, + ePhysicalDeviceMapMemoryPlacedFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT, + ePhysicalDeviceMapMemoryPlacedPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT, + eMemoryMapPlacedInfoEXT = VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT, ePhysicalDeviceShaderAtomicFloat2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT, eSurfacePresentModeEXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT, eSurfacePresentScalingCapabilitiesEXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT, @@ -1417,7 +1421,8 @@ namespace VULKAN_HPP_NAMESPACE ePushDescriptorSetWithTemplateInfoKHR = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR, eSetDescriptorBufferOffsetsInfoEXT = VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT, eBindDescriptorBufferEmbeddedSamplersInfoEXT = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT, - ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV + ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV, + ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV }; enum class PipelineCacheHeaderVersion @@ -2185,6 +2190,7 @@ namespace VULKAN_HPP_NAMESPACE enum class MemoryMapFlagBits : VkMemoryMapFlags { + ePlacedEXT = VK_MEMORY_MAP_PLACED_BIT_EXT }; using MemoryMapFlags = Flags; @@ -2193,7 +2199,7 @@ namespace VULKAN_HPP_NAMESPACE struct FlagTraits { static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryMapFlags allFlags = {}; + static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryMapFlags allFlags = MemoryMapFlagBits::ePlacedEXT; }; enum class ImageAspectFlagBits : VkImageAspectFlags @@ -6078,6 +6084,7 @@ namespace VULKAN_HPP_NAMESPACE enum class MemoryUnmapFlagBitsKHR : VkMemoryUnmapFlagsKHR { + eReserveEXT = VK_MEMORY_UNMAP_RESERVE_BIT_EXT }; using MemoryUnmapFlagsKHR = Flags; @@ -6086,7 +6093,7 @@ namespace VULKAN_HPP_NAMESPACE struct FlagTraits { static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryUnmapFlagsKHR allFlags = {}; + static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryUnmapFlagsKHR allFlags = MemoryUnmapFlagBitsKHR::eReserveEXT; }; //=== VK_EXT_surface_maintenance1 === diff --git a/third_party/vulkan/vulkan_extension_inspection.hpp b/third_party/vulkan/vulkan_extension_inspection.hpp index 75958da..6c5c6ea 100644 --- a/third_party/vulkan/vulkan_extension_inspection.hpp +++ b/third_party/vulkan/vulkan_extension_inspection.hpp @@ -279,6 +279,7 @@ namespace VULKAN_HPP_NAMESPACE "VK_KHR_pipeline_executable_properties", "VK_EXT_host_image_copy", "VK_KHR_map_memory2", + "VK_EXT_map_memory_placed", "VK_EXT_shader_atomic_float2", "VK_EXT_swapchain_maintenance1", "VK_EXT_shader_demote_to_helper_invocation", @@ -432,7 +433,8 @@ namespace VULKAN_HPP_NAMESPACE "VK_KHR_calibrated_timestamps", "VK_KHR_shader_expect_assume", "VK_KHR_maintenance6", - "VK_NV_descriptor_pool_overallocation" + "VK_NV_descriptor_pool_overallocation", + "VK_NV_shader_atomic_float16_vector" }; return deviceExtensions; } @@ -1398,6 +1400,11 @@ namespace VULKAN_HPP_NAMESPACE "VK_KHR_copy_commands2", "VK_KHR_format_feature_flags2", } } } } }, + { "VK_EXT_map_memory_placed", + { { "VK_VERSION_1_0", + { { + "VK_KHR_map_memory2", + } } } } }, { "VK_EXT_shader_atomic_float2", { { "VK_VERSION_1_0", { { @@ -2786,14 +2793,15 @@ namespace VULKAN_HPP_NAMESPACE || ( extension == "VK_KHR_buffer_device_address" ) || ( extension == "VK_EXT_line_rasterization" ) || ( extension == "VK_EXT_shader_atomic_float" ) || ( extension == "VK_EXT_host_query_reset" ) || ( extension == "VK_EXT_index_type_uint8" ) || ( extension == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_KHR_deferred_host_operations" ) || ( extension == "VK_KHR_pipeline_executable_properties" ) || - ( extension == "VK_EXT_host_image_copy" ) || ( extension == "VK_KHR_map_memory2" ) || ( extension == "VK_EXT_shader_atomic_float2" ) || - ( extension == "VK_EXT_swapchain_maintenance1" ) || ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) || - ( extension == "VK_NV_device_generated_commands" ) || ( extension == "VK_NV_inherited_viewport_scissor" ) || - ( extension == "VK_KHR_shader_integer_dot_product" ) || ( extension == "VK_EXT_texel_buffer_alignment" ) || - ( extension == "VK_QCOM_render_pass_transform" ) || ( extension == "VK_EXT_depth_bias_control" ) || ( extension == "VK_EXT_device_memory_report" ) || - ( extension == "VK_EXT_robustness2" ) || ( extension == "VK_EXT_custom_border_color" ) || ( extension == "VK_GOOGLE_user_type" ) || - ( extension == "VK_KHR_pipeline_library" ) || ( extension == "VK_NV_present_barrier" ) || ( extension == "VK_KHR_shader_non_semantic_info" ) || - ( extension == "VK_KHR_present_id" ) || ( extension == "VK_EXT_private_data" ) || ( extension == "VK_EXT_pipeline_creation_cache_control" ) || + ( extension == "VK_EXT_host_image_copy" ) || ( extension == "VK_KHR_map_memory2" ) || ( extension == "VK_EXT_map_memory_placed" ) || + ( extension == "VK_EXT_shader_atomic_float2" ) || ( extension == "VK_EXT_swapchain_maintenance1" ) || + ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) || ( extension == "VK_NV_device_generated_commands" ) || + ( extension == "VK_NV_inherited_viewport_scissor" ) || ( extension == "VK_KHR_shader_integer_dot_product" ) || + ( extension == "VK_EXT_texel_buffer_alignment" ) || ( extension == "VK_QCOM_render_pass_transform" ) || + ( extension == "VK_EXT_depth_bias_control" ) || ( extension == "VK_EXT_device_memory_report" ) || ( extension == "VK_EXT_robustness2" ) || + ( extension == "VK_EXT_custom_border_color" ) || ( extension == "VK_GOOGLE_user_type" ) || ( extension == "VK_KHR_pipeline_library" ) || + ( extension == "VK_NV_present_barrier" ) || ( extension == "VK_KHR_shader_non_semantic_info" ) || ( extension == "VK_KHR_present_id" ) || + ( extension == "VK_EXT_private_data" ) || ( extension == "VK_EXT_pipeline_creation_cache_control" ) || ( extension == "VK_KHR_video_encode_queue" ) || ( extension == "VK_NV_device_diagnostics_config" ) || ( extension == "VK_QCOM_render_pass_store_ops" ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -2866,7 +2874,7 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ || ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) || ( extension == "VK_KHR_calibrated_timestamps" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) || - ( extension == "VK_NV_descriptor_pool_overallocation" ); + ( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ); } VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension ) diff --git a/third_party/vulkan/vulkan_funcs.hpp b/third_party/vulkan/vulkan_funcs.hpp index 3c8d9ae..0a09ecc 100644 --- a/third_party/vulkan/vulkan_funcs.hpp +++ b/third_party/vulkan/vulkan_funcs.hpp @@ -46,7 +46,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &instance ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::createInstance" ); - return createResultValueType( result, instance ); + return createResultValueType( result, std::move( instance ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -131,7 +131,7 @@ namespace VULKAN_HPP_NAMESPACE { physicalDevices.resize( physicalDeviceCount ); } - return createResultValueType( result, physicalDevices ); + return createResultValueType( result, std::move( physicalDevices ) ); } template ( &imageFormatProperties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" ); - return createResultValueType( result, imageFormatProperties ); + return createResultValueType( result, std::move( imageFormatProperties ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -455,7 +455,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &device ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDevice" ); - return createResultValueType( result, device ); + return createResultValueType( result, std::move( device ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -545,7 +545,7 @@ namespace VULKAN_HPP_NAMESPACE { properties.resize( propertyCount ); } - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } template < @@ -582,7 +582,7 @@ namespace VULKAN_HPP_NAMESPACE { properties.resize( propertyCount ); } - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -627,7 +627,7 @@ namespace VULKAN_HPP_NAMESPACE { properties.resize( propertyCount ); } - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } template < @@ -664,7 +664,7 @@ namespace VULKAN_HPP_NAMESPACE { properties.resize( propertyCount ); } - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -706,7 +706,7 @@ namespace VULKAN_HPP_NAMESPACE { properties.resize( propertyCount ); } - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } template ( &memory ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemory" ); - return createResultValueType( result, memory ); + return createResultValueType( result, std::move( memory ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -1070,7 +1070,7 @@ namespace VULKAN_HPP_NAMESPACE &pData ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory" ); - return createResultValueType( result, pData ); + return createResultValueType( result, std::move( pData ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -1522,7 +1522,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &fence ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFence" ); - return createResultValueType( result, fence ); + return createResultValueType( result, std::move( fence ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -1719,7 +1719,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &semaphore ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphore" ); - return createResultValueType( result, semaphore ); + return createResultValueType( result, std::move( semaphore ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -1831,7 +1831,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &event ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createEvent" ); - return createResultValueType( result, event ); + return createResultValueType( result, std::move( event ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -2014,7 +2014,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &queryPool ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPool" ); - return createResultValueType( result, queryPool ); + return createResultValueType( result, std::move( queryPool ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -2146,7 +2146,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResults", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); - return ResultValue>( static_cast( result ), data ); + return ResultValue>( static_cast( result ), std::move( data ) ); } template @@ -2174,7 +2174,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResult", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); - return ResultValue( static_cast( result ), data ); + return ResultValue( static_cast( result ), std::move( data ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -2209,7 +2209,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &buffer ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBuffer" ); - return createResultValueType( result, buffer ); + return createResultValueType( result, std::move( buffer ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -2321,7 +2321,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &view ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferView" ); - return createResultValueType( result, view ); + return createResultValueType( result, std::move( view ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -2433,7 +2433,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &image ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImage" ); - return createResultValueType( result, image ); + return createResultValueType( result, std::move( image ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -2578,7 +2578,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &view ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageView" ); - return createResultValueType( result, view ); + return createResultValueType( result, std::move( view ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -2692,7 +2692,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &shaderModule ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModule" ); - return createResultValueType( result, shaderModule ); + return createResultValueType( result, std::move( shaderModule ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -2806,7 +2806,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &pipelineCache ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCache" ); - return createResultValueType( result, pipelineCache ); + return createResultValueType( result, std::move( pipelineCache ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -2927,7 +2927,7 @@ namespace VULKAN_HPP_NAMESPACE { data.resize( dataSize ); } - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } template >( static_cast( result ), pipelines ); + return ResultValue>( static_cast( result ), + std::move( pipelines ) ); } template >( static_cast( result ), pipelines ); + return ResultValue>( static_cast( result ), + std::move( pipelines ) ); } template @@ -3095,7 +3097,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipeline", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); - return ResultValue( static_cast( result ), pipeline ); + return ResultValue( static_cast( result ), std::move( pipeline ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -3244,7 +3246,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); - return ResultValue>( static_cast( result ), pipelines ); + return ResultValue>( static_cast( result ), + std::move( pipelines ) ); } template >( static_cast( result ), pipelines ); + return ResultValue>( static_cast( result ), + std::move( pipelines ) ); } template @@ -3301,7 +3305,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipeline", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); - return ResultValue( static_cast( result ), pipeline ); + return ResultValue( static_cast( result ), std::move( pipeline ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -3493,7 +3497,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &pipelineLayout ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayout" ); - return createResultValueType( result, pipelineLayout ); + return createResultValueType( result, std::move( pipelineLayout ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -3605,7 +3609,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &sampler ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSampler" ); - return createResultValueType( result, sampler ); + return createResultValueType( result, std::move( sampler ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -3717,7 +3721,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &setLayout ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayout" ); - return createResultValueType( result, setLayout ); + return createResultValueType( result, std::move( setLayout ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -3835,7 +3839,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &descriptorPool ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPool" ); - return createResultValueType( result, descriptorPool ); + return createResultValueType( result, std::move( descriptorPool ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -3966,7 +3970,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" ); - return createResultValueType( result, descriptorSets ); + return createResultValueType( result, std::move( descriptorSets ) ); } template ( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" ); - return createResultValueType( result, descriptorSets ); + return createResultValueType( result, std::move( descriptorSets ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -4169,7 +4173,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &framebuffer ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebuffer" ); - return createResultValueType( result, framebuffer ); + return createResultValueType( result, std::move( framebuffer ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -4283,7 +4287,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &renderPass ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass" ); - return createResultValueType( result, renderPass ); + return createResultValueType( result, std::move( renderPass ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -4423,7 +4427,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &commandPool ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPool" ); - return createResultValueType( result, commandPool ); + return createResultValueType( result, std::move( commandPool ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -4556,7 +4560,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" ); - return createResultValueType( result, commandBuffers ); + return createResultValueType( result, std::move( commandBuffers ) ); } template ( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" ); - return createResultValueType( result, commandBuffers ); + return createResultValueType( result, std::move( commandBuffers ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -5738,7 +5742,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( d.vkEnumerateInstanceVersion( &apiVersion ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceVersion" ); - return createResultValueType( result, apiVersion ); + return createResultValueType( result, std::move( apiVersion ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -5889,7 +5893,7 @@ namespace VULKAN_HPP_NAMESPACE { physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); } - return createResultValueType( result, physicalDeviceGroupProperties ); + return createResultValueType( result, std::move( physicalDeviceGroupProperties ) ); } template ( &imageFormatProperties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); - return createResultValueType( result, imageFormatProperties ); + return createResultValueType( result, std::move( imageFormatProperties ) ); } template @@ -6283,7 +6287,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &imageFormatProperties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); - return createResultValueType( result, structureChain ); + return createResultValueType( result, std::move( structureChain ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -6616,7 +6620,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &ycbcrConversion ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversion" ); - return createResultValueType( result, ycbcrConversion ); + return createResultValueType( result, std::move( ycbcrConversion ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -6739,7 +6743,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &descriptorUpdateTemplate ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplate" ); - return createResultValueType( result, descriptorUpdateTemplate ); + return createResultValueType( result, std::move( descriptorUpdateTemplate ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -7076,7 +7080,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &renderPass ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2" ); - return createResultValueType( result, renderPass ); + return createResultValueType( result, std::move( renderPass ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -7211,7 +7215,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( d.vkGetSemaphoreCounterValue( m_device, static_cast( semaphore ), &value ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValue" ); - return createResultValueType( result, value ); + return createResultValueType( result, std::move( value ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -7387,7 +7391,7 @@ namespace VULKAN_HPP_NAMESPACE { toolProperties.resize( toolCount ); } - return createResultValueType( result, toolProperties ); + return createResultValueType( result, std::move( toolProperties ) ); } template < @@ -7425,7 +7429,7 @@ namespace VULKAN_HPP_NAMESPACE { toolProperties.resize( toolCount ); } - return createResultValueType( result, toolProperties ); + return createResultValueType( result, std::move( toolProperties ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -7462,7 +7466,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &privateDataSlot ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlot" ); - return createResultValueType( result, privateDataSlot ); + return createResultValueType( result, std::move( privateDataSlot ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -8354,7 +8358,7 @@ namespace VULKAN_HPP_NAMESPACE m_physicalDevice, queueFamilyIndex, static_cast( surface ), reinterpret_cast( &supported ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" ); - return createResultValueType( result, supported ); + return createResultValueType( result, std::move( supported ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -8383,7 +8387,7 @@ namespace VULKAN_HPP_NAMESPACE m_physicalDevice, static_cast( surface ), reinterpret_cast( &surfaceCapabilities ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" ); - return createResultValueType( result, surfaceCapabilities ); + return createResultValueType( result, std::move( surfaceCapabilities ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -8428,7 +8432,7 @@ namespace VULKAN_HPP_NAMESPACE { surfaceFormats.resize( surfaceFormatCount ); } - return createResultValueType( result, surfaceFormats ); + return createResultValueType( result, std::move( surfaceFormats ) ); } template ( &swapchain ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHR" ); - return createResultValueType( result, swapchain ); + return createResultValueType( result, std::move( swapchain ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -8706,7 +8710,7 @@ namespace VULKAN_HPP_NAMESPACE { swapchainImages.resize( swapchainImageCount ); } - return createResultValueType( result, swapchainImages ); + return createResultValueType( result, std::move( swapchainImages ) ); } template ( static_cast( result ), imageIndex ); + return ResultValue( static_cast( result ), std::move( imageIndex ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -8836,7 +8840,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast( &deviceGroupPresentCapabilities ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" ); - return createResultValueType( result, deviceGroupPresentCapabilities ); + return createResultValueType( result, std::move( deviceGroupPresentCapabilities ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -8866,7 +8870,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, static_cast( surface ), reinterpret_cast( &modes ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" ); - return createResultValueType( result, modes ); + return createResultValueType( result, std::move( modes ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -8912,7 +8916,7 @@ namespace VULKAN_HPP_NAMESPACE { rects.resize( rectCount ); } - return createResultValueType( result, rects ); + return createResultValueType( result, std::move( rects ) ); } template ( static_cast( result ), imageIndex ); + return ResultValue( static_cast( result ), std::move( imageIndex ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -9025,7 +9029,7 @@ namespace VULKAN_HPP_NAMESPACE { properties.resize( propertyCount ); } - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } template < @@ -9059,7 +9063,7 @@ namespace VULKAN_HPP_NAMESPACE { properties.resize( propertyCount ); } - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -9103,7 +9107,7 @@ namespace VULKAN_HPP_NAMESPACE { properties.resize( propertyCount ); } - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } template < @@ -9139,7 +9143,7 @@ namespace VULKAN_HPP_NAMESPACE { properties.resize( propertyCount ); } - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -9183,7 +9187,7 @@ namespace VULKAN_HPP_NAMESPACE { displays.resize( displayCount ); } - return createResultValueType( result, displays ); + return createResultValueType( result, std::move( displays ) ); } template ( &mode ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHR" ); - return createResultValueType( result, mode ); + return createResultValueType( result, std::move( mode ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -9399,7 +9403,7 @@ namespace VULKAN_HPP_NAMESPACE m_physicalDevice, static_cast( mode ), planeIndex, reinterpret_cast( &capabilities ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" ); - return createResultValueType( result, capabilities ); + return createResultValueType( result, std::move( capabilities ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -9436,7 +9440,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surface ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHR" ); - return createResultValueType( result, surface ); + return createResultValueType( result, std::move( surface ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -9503,7 +9507,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( swapchains.data() ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" ); - return createResultValueType( result, swapchains ); + return createResultValueType( result, std::move( swapchains ) ); } template ( swapchains.data() ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" ); - return createResultValueType( result, swapchains ); + return createResultValueType( result, std::move( swapchains ) ); } template @@ -9552,7 +9556,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &swapchain ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHR" ); - return createResultValueType( result, swapchain ); + return createResultValueType( result, std::move( swapchain ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -9682,7 +9686,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surface ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHR" ); - return createResultValueType( result, surface ); + return createResultValueType( result, std::move( surface ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -9773,7 +9777,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surface ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHR" ); - return createResultValueType( result, surface ); + return createResultValueType( result, std::move( surface ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -9868,7 +9872,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surface ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHR" ); - return createResultValueType( result, surface ); + return createResultValueType( result, std::move( surface ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -9960,7 +9964,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surface ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHR" ); - return createResultValueType( result, surface ); + return createResultValueType( result, std::move( surface ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -10026,7 +10030,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surface ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHR" ); - return createResultValueType( result, surface ); + return createResultValueType( result, std::move( surface ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -10099,7 +10103,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &callback ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXT" ); - return createResultValueType( result, callback ); + return createResultValueType( result, std::move( callback ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -10364,7 +10368,7 @@ namespace VULKAN_HPP_NAMESPACE m_physicalDevice, reinterpret_cast( &videoProfile ), reinterpret_cast( &capabilities ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); - return createResultValueType( result, capabilities ); + return createResultValueType( result, std::move( capabilities ) ); } template @@ -10382,7 +10386,7 @@ namespace VULKAN_HPP_NAMESPACE m_physicalDevice, reinterpret_cast( &videoProfile ), reinterpret_cast( &capabilities ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); - return createResultValueType( result, structureChain ); + return createResultValueType( result, std::move( structureChain ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -10435,7 +10439,7 @@ namespace VULKAN_HPP_NAMESPACE { videoFormatProperties.resize( videoFormatPropertyCount ); } - return createResultValueType( result, videoFormatProperties ); + return createResultValueType( result, std::move( videoFormatProperties ) ); } template ( &videoSession ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHR" ); - return createResultValueType( result, videoSession ); + return createResultValueType( result, std::move( videoSession ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -10763,7 +10767,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &videoSessionParameters ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHR" ); - return createResultValueType( result, videoSessionParameters ); + return createResultValueType( result, std::move( videoSessionParameters ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -11189,7 +11193,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &module ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVX" ); - return createResultValueType( result, module ); + return createResultValueType( result, std::move( module ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -11251,7 +11255,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &function ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVX" ); - return createResultValueType( result, function ); + return createResultValueType( result, std::move( function ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -11457,7 +11461,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetImageViewAddressNVX( m_device, static_cast( imageView ), reinterpret_cast( &properties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewAddressNVX" ); - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -11561,7 +11565,7 @@ namespace VULKAN_HPP_NAMESPACE { info.resize( infoSize ); } - return createResultValueType( result, info ); + return createResultValueType( result, std::move( info ) ); } template ( &surface ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGP" ); - return createResultValueType( result, surface ); + return createResultValueType( result, std::move( surface ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -11763,7 +11767,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &externalImageFormatProperties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" ); - return createResultValueType( result, externalImageFormatProperties ); + return createResultValueType( result, std::move( externalImageFormatProperties ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -11796,7 +11800,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetMemoryWin32HandleNV( m_device, static_cast( memory ), static_cast( handleType ), &handle ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleNV" ); - return createResultValueType( result, handle ); + return createResultValueType( result, std::move( handle ) ); } # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -11966,7 +11970,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &imageFormatProperties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); - return createResultValueType( result, imageFormatProperties ); + return createResultValueType( result, std::move( imageFormatProperties ) ); } template @@ -11987,7 +11991,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &imageFormatProperties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); - return createResultValueType( result, structureChain ); + return createResultValueType( result, std::move( structureChain ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -12340,7 +12344,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surface ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNN" ); - return createResultValueType( result, surface ); + return createResultValueType( result, std::move( surface ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -12425,7 +12429,7 @@ namespace VULKAN_HPP_NAMESPACE { physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); } - return createResultValueType( result, physicalDeviceGroupProperties ); + return createResultValueType( result, std::move( physicalDeviceGroupProperties ) ); } template ( &getWin32HandleInfo ), &handle ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" ); - return createResultValueType( result, handle ); + return createResultValueType( result, std::move( handle ) ); } # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -12565,7 +12569,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &memoryWin32HandleProperties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" ); - return createResultValueType( result, memoryWin32HandleProperties ); + return createResultValueType( result, std::move( memoryWin32HandleProperties ) ); } # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -12596,7 +12600,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( d.vkGetMemoryFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR" ); - return createResultValueType( result, fd ); + return createResultValueType( result, std::move( fd ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -12626,7 +12630,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, static_cast( handleType ), fd, reinterpret_cast( &memoryFdProperties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" ); - return createResultValueType( result, memoryFdProperties ); + return createResultValueType( result, std::move( memoryFdProperties ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -12720,7 +12724,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" ); - return createResultValueType( result, handle ); + return createResultValueType( result, std::move( handle ) ); } # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -12777,7 +12781,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" ); - return createResultValueType( result, fd ); + return createResultValueType( result, std::move( fd ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -12925,7 +12929,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &descriptorUpdateTemplate ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateKHR" ); - return createResultValueType( result, descriptorUpdateTemplate ); + return createResultValueType( result, std::move( descriptorUpdateTemplate ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -13122,7 +13126,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast( &display ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXT" ); - return createResultValueType( result, display ); + return createResultValueType( result, std::move( display ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -13176,7 +13180,7 @@ namespace VULKAN_HPP_NAMESPACE m_physicalDevice, static_cast( surface ), reinterpret_cast( &surfaceCapabilities ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT" ); - return createResultValueType( result, surfaceCapabilities ); + return createResultValueType( result, std::move( surfaceCapabilities ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -13244,7 +13248,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &fence ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXT" ); - return createResultValueType( result, fence ); + return createResultValueType( result, std::move( fence ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -13310,7 +13314,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &fence ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXT" ); - return createResultValueType( result, fence ); + return createResultValueType( result, std::move( fence ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -13367,7 +13371,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetSwapchainCounterEXT( m_device, static_cast( swapchain ), static_cast( counter ), &counterValue ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainCounterEXT" ); - return createResultValueType( result, counterValue ); + return createResultValueType( result, std::move( counterValue ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -13399,7 +13403,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, static_cast( swapchain ), reinterpret_cast( &displayTimingProperties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRefreshCycleDurationGOOGLE" ); - return createResultValueType( result, displayTimingProperties ); + return createResultValueType( result, std::move( displayTimingProperties ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -13451,7 +13455,7 @@ namespace VULKAN_HPP_NAMESPACE { presentationTimings.resize( presentationTimingCount ); } - return createResultValueType( result, presentationTimings ); + return createResultValueType( result, std::move( presentationTimings ) ); } template < @@ -13494,7 +13498,7 @@ namespace VULKAN_HPP_NAMESPACE { presentationTimings.resize( presentationTimingCount ); } - return createResultValueType( result, presentationTimings ); + return createResultValueType( result, std::move( presentationTimings ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -13616,7 +13620,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &renderPass ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHR" ); - return createResultValueType( result, renderPass ); + return createResultValueType( result, std::move( renderPass ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -13838,7 +13842,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" ); - return createResultValueType( result, handle ); + return createResultValueType( result, std::move( handle ) ); } # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -13895,7 +13899,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( d.vkGetFenceFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR" ); - return createResultValueType( result, fd ); + return createResultValueType( result, std::move( fd ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -13961,7 +13965,7 @@ namespace VULKAN_HPP_NAMESPACE counters.resize( counterCount ); counterDescriptions.resize( counterCount ); } - return createResultValueType( result, data_ ); + return createResultValueType( result, std::move( data_ ) ); } template ( &surfaceCapabilities ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); - return createResultValueType( result, surfaceCapabilities ); + return createResultValueType( result, std::move( surfaceCapabilities ) ); } template @@ -14136,7 +14140,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surfaceCapabilities ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); - return createResultValueType( result, structureChain ); + return createResultValueType( result, std::move( structureChain ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -14187,7 +14191,7 @@ namespace VULKAN_HPP_NAMESPACE { surfaceFormats.resize( surfaceFormatCount ); } - return createResultValueType( result, surfaceFormats ); + return createResultValueType( result, std::move( surfaceFormats ) ); } template @@ -14273,7 +14277,7 @@ namespace VULKAN_HPP_NAMESPACE { structureChains[i].template get() = surfaceFormats[i]; } - return createResultValueType( result, structureChains ); + return createResultValueType( result, std::move( structureChains ) ); } template () = surfaceFormats[i]; } - return createResultValueType( result, structureChains ); + return createResultValueType( result, std::move( structureChains ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -14371,7 +14375,7 @@ namespace VULKAN_HPP_NAMESPACE { properties.resize( propertyCount ); } - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } template < @@ -14407,7 +14411,7 @@ namespace VULKAN_HPP_NAMESPACE { properties.resize( propertyCount ); } - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -14452,7 +14456,7 @@ namespace VULKAN_HPP_NAMESPACE { properties.resize( propertyCount ); } - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } template < @@ -14489,7 +14493,7 @@ namespace VULKAN_HPP_NAMESPACE { properties.resize( propertyCount ); } - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -14535,7 +14539,7 @@ namespace VULKAN_HPP_NAMESPACE { properties.resize( propertyCount ); } - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } template < @@ -14574,7 +14578,7 @@ namespace VULKAN_HPP_NAMESPACE { properties.resize( propertyCount ); } - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -14607,7 +14611,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &capabilities ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" ); - return createResultValueType( result, capabilities ); + return createResultValueType( result, std::move( capabilities ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -14647,7 +14651,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surface ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVK" ); - return createResultValueType( result, surface ); + return createResultValueType( result, std::move( surface ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -14713,7 +14717,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surface ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVK" ); - return createResultValueType( result, surface ); + return createResultValueType( result, std::move( surface ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -14933,7 +14937,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &messenger ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXT" ); - return createResultValueType( result, messenger ); + return createResultValueType( result, std::move( messenger ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -15080,7 +15084,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, &buffer, reinterpret_cast( &properties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } template @@ -15100,7 +15104,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, &buffer, reinterpret_cast( &properties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); - return createResultValueType( result, structureChain ); + return createResultValueType( result, std::move( structureChain ) ); } # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -15131,7 +15135,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast( &info ), &buffer ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" ); - return createResultValueType( result, buffer ); + return createResultValueType( result, std::move( buffer ) ); } # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ @@ -15182,7 +15186,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDX", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); - return ResultValue>( static_cast( result ), pipelines ); + return ResultValue>( static_cast( result ), + std::move( pipelines ) ); } template >( static_cast( result ), pipelines ); + return ResultValue>( static_cast( result ), + std::move( pipelines ) ); } template @@ -15239,7 +15245,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelineAMDX", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); - return ResultValue( static_cast( result ), pipeline ); + return ResultValue( static_cast( result ), std::move( pipeline ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -15375,7 +15381,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, static_cast( executionGraph ), reinterpret_cast( &sizeInfo ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getExecutionGraphPipelineScratchSizeAMDX" ); - return createResultValueType( result, sizeInfo ); + return createResultValueType( result, std::move( sizeInfo ) ); } # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -15406,7 +15412,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, static_cast( executionGraph ), reinterpret_cast( &nodeInfo ), &nodeIndex ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getExecutionGraphPipelineNodeIndexAMDX" ); - return createResultValueType( result, nodeIndex ); + return createResultValueType( result, std::move( nodeIndex ) ); } # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -15741,7 +15747,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &accelerationStructure ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHR" ); - return createResultValueType( result, accelerationStructure ); + return createResultValueType( result, std::move( accelerationStructure ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -16131,7 +16137,7 @@ namespace VULKAN_HPP_NAMESPACE stride ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" ); - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } template @@ -16158,7 +16164,7 @@ namespace VULKAN_HPP_NAMESPACE stride ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR" ); - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -16480,7 +16486,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); - return ResultValue>( static_cast( result ), pipelines ); + return ResultValue>( static_cast( result ), + std::move( pipelines ) ); } template >( static_cast( result ), pipelines ); + return ResultValue>( static_cast( result ), + std::move( pipelines ) ); } template @@ -16547,7 +16555,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); - return ResultValue( static_cast( result ), pipeline ); + return ResultValue( static_cast( result ), std::move( pipeline ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -16701,7 +16709,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, static_cast( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast( data.data() ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" ); - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } template @@ -16719,7 +16727,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, static_cast( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast( &data ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleKHR" ); - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -16754,7 +16762,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, static_cast( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast( data.data() ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR" ); - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } template @@ -16772,7 +16780,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, static_cast( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast( &data ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandleKHR" ); - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -16871,7 +16879,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &ycbcrConversion ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHR" ); - return createResultValueType( result, ycbcrConversion ); + return createResultValueType( result, std::move( ycbcrConversion ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -17014,7 +17022,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, static_cast( image ), reinterpret_cast( &properties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageDrmFormatModifierPropertiesEXT" ); - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -17053,7 +17061,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &validationCache ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXT" ); - return createResultValueType( result, validationCache ); + return createResultValueType( result, std::move( validationCache ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -17209,7 +17217,7 @@ namespace VULKAN_HPP_NAMESPACE { data.resize( dataSize ); } - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } template ( &accelerationStructure ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNV" ); - return createResultValueType( result, accelerationStructure ); + return createResultValueType( result, std::move( accelerationStructure ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -17662,7 +17670,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); - return ResultValue>( static_cast( result ), pipelines ); + return ResultValue>( static_cast( result ), + std::move( pipelines ) ); } template >( static_cast( result ), pipelines ); + return ResultValue>( static_cast( result ), + std::move( pipelines ) ); } template @@ -17719,7 +17729,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNV", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); - return ResultValue( static_cast( result ), pipeline ); + return ResultValue( static_cast( result ), std::move( pipeline ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -17856,7 +17866,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, static_cast( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast( data.data() ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" ); - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } template @@ -17874,7 +17884,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, static_cast( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast( &data ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleNV" ); - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -17905,7 +17915,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, static_cast( accelerationStructure ), data.size() * sizeof( DataType ), reinterpret_cast( data.data() ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" ); - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } template @@ -17922,7 +17932,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, static_cast( accelerationStructure ), sizeof( DataType ), reinterpret_cast( &data ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" ); - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -18121,7 +18131,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &memoryHostPointerProperties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT" ); - return createResultValueType( result, memoryHostPointerProperties ); + return createResultValueType( result, std::move( memoryHostPointerProperties ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -18184,7 +18194,7 @@ namespace VULKAN_HPP_NAMESPACE { timeDomains.resize( timeDomainCount ); } - return createResultValueType( result, timeDomains ); + return createResultValueType( result, std::move( timeDomains ) ); } template ( timestampInfos.data() ), timestamps.data(), &maxDeviation ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); - return createResultValueType( result, data_ ); + return createResultValueType( result, std::move( data_ ) ); } template ( timestampInfos.data() ), timestamps.data(), &maxDeviation ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); - return createResultValueType( result, data_ ); + return createResultValueType( result, std::move( data_ ) ); } template @@ -18299,7 +18309,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetCalibratedTimestampsEXT( m_device, 1, reinterpret_cast( ×tampInfo ), ×tamp, &maxDeviation ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" ); - return createResultValueType( result, data_ ); + return createResultValueType( result, std::move( data_ ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -18505,7 +18515,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( d.vkGetSemaphoreCounterValueKHR( m_device, static_cast( semaphore ), &value ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValueKHR" ); - return createResultValueType( result, value ); + return createResultValueType( result, std::move( value ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -18708,7 +18718,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &configuration ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTEL" ); - return createResultValueType( result, configuration ); + return createResultValueType( result, std::move( configuration ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -18839,7 +18849,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, static_cast( parameter ), reinterpret_cast( &value ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL" ); - return createResultValueType( result, value ); + return createResultValueType( result, std::move( value ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -18891,7 +18901,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surface ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIA" ); - return createResultValueType( result, surface ); + return createResultValueType( result, std::move( surface ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -18957,7 +18967,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surface ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXT" ); - return createResultValueType( result, surface ); + return createResultValueType( result, std::move( surface ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -19032,7 +19042,7 @@ namespace VULKAN_HPP_NAMESPACE { fragmentShadingRates.resize( fragmentShadingRateCount ); } - return createResultValueType( result, fragmentShadingRates ); + return createResultValueType( result, std::move( fragmentShadingRates ) ); } template ( &surfaceInfo ), reinterpret_cast( &modes ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" ); - return createResultValueType( result, modes ); + return createResultValueType( result, std::move( modes ) ); } # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -19680,7 +19690,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surface ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXT" ); - return createResultValueType( result, surface ); + return createResultValueType( result, std::move( surface ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -20023,7 +20033,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &deferredOperation ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHR" ); - return createResultValueType( result, deferredOperation ); + return createResultValueType( result, std::move( deferredOperation ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -20216,7 +20226,7 @@ namespace VULKAN_HPP_NAMESPACE { properties.resize( executableCount ); } - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } template ( d.vkMapMemory2KHR( m_device, reinterpret_cast( &memoryMapInfo ), &pData ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory2KHR" ); - return createResultValueType( result, pData ); + return createResultValueType( result, std::move( pData ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ template - VULKAN_HPP_INLINE Result Device::unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR * pMemoryUnmapInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR * pMemoryUnmapInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); return static_cast( d.vkUnmapMemory2KHR( m_device, reinterpret_cast( pMemoryUnmapInfo ) ) ); @@ -20666,15 +20676,19 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE void Device::unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE typename ResultValueType::type Device::unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo, + Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) VULKAN_HPP_ASSERT( d.vkUnmapMemory2KHR && "Function requires " ); # endif - d.vkUnmapMemory2KHR( m_device, reinterpret_cast( &memoryUnmapInfo ) ); + VULKAN_HPP_NAMESPACE::Result result = + static_cast( d.vkUnmapMemory2KHR( m_device, reinterpret_cast( &memoryUnmapInfo ) ) ); + resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::unmapMemory2KHR" ); + + return createResultValueType( result ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -20852,7 +20866,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &indirectCommandsLayout ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNV" ); - return createResultValueType( result, indirectCommandsLayout ); + return createResultValueType( result, std::move( indirectCommandsLayout ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -21016,7 +21030,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( d.vkGetDrmDisplayEXT( m_physicalDevice, drmFd, connectorId, reinterpret_cast( &display ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDrmDisplayEXT" ); - return createResultValueType( result, display ); + return createResultValueType( result, std::move( display ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -21075,7 +21089,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &privateDataSlot ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXT" ); - return createResultValueType( result, privateDataSlot ); + return createResultValueType( result, std::move( privateDataSlot ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -21228,7 +21242,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &qualityLevelProperties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" ); - return createResultValueType( result, qualityLevelProperties ); + return createResultValueType( result, std::move( qualityLevelProperties ) ); } template @@ -21251,7 +21265,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &qualityLevelProperties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" ); - return createResultValueType( result, structureChain ); + return createResultValueType( result, std::move( structureChain ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -21310,7 +21324,7 @@ namespace VULKAN_HPP_NAMESPACE } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); - return createResultValueType( result, data_ ); + return createResultValueType( result, std::move( data_ ) ); } template @@ -21395,7 +21409,7 @@ namespace VULKAN_HPP_NAMESPACE } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); - return createResultValueType( result, data_ ); + return createResultValueType( result, std::move( data_ ) ); } template ( &module ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaModuleNV" ); - return createResultValueType( result, module ); + return createResultValueType( result, std::move( module ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -21573,7 +21587,7 @@ namespace VULKAN_HPP_NAMESPACE { cacheData.resize( cacheSize ); } - return createResultValueType( result, cacheData ); + return createResultValueType( result, std::move( cacheData ) ); } template ( &function ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaFunctionNV" ); - return createResultValueType( result, function ); + return createResultValueType( result, std::move( function ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -22257,7 +22271,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetBufferOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast( &info ), &data ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getBufferOpaqueCaptureDescriptorDataEXT" ); - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -22286,7 +22300,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetImageOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast( &info ), &data ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDescriptorDataEXT" ); - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -22315,7 +22329,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetImageViewOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast( &info ), &data ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewOpaqueCaptureDescriptorDataEXT" ); - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -22344,7 +22358,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetSamplerOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast( &info ), &data ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSamplerOpaqueCaptureDescriptorDataEXT" ); - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -22374,7 +22388,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, reinterpret_cast( &info ), &data ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT" ); - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -22578,8 +22592,9 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::getFaultInfoEXT( Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + Device::getFaultInfoEXT( Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) @@ -22589,13 +22604,38 @@ namespace VULKAN_HPP_NAMESPACE std::pair data_; VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT & faultCounts = data_.first; VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT & faultInfo = data_.second; - VULKAN_HPP_NAMESPACE::Result result = static_cast( d.vkGetDeviceFaultInfoEXT( - m_device, reinterpret_cast( &faultCounts ), reinterpret_cast( &faultInfo ) ) ); + VULKAN_HPP_NAMESPACE::Result result; + do + { + result = + static_cast( d.vkGetDeviceFaultInfoEXT( m_device, reinterpret_cast( &faultCounts ), nullptr ) ); + if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) + { + std::free( faultInfo.pAddressInfos ); + if ( faultCounts.addressInfoCount ) + { + faultInfo.pAddressInfos = reinterpret_cast( + std::malloc( faultCounts.addressInfoCount * sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT ) ) ); + } + std::free( faultInfo.pVendorInfos ); + if ( faultCounts.vendorInfoCount ) + { + faultInfo.pVendorInfos = reinterpret_cast( + std::malloc( faultCounts.vendorInfoCount * sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT ) ) ); + } + std::free( faultInfo.pVendorBinaryData ); + if ( faultCounts.vendorBinarySize ) + { + faultInfo.pVendorBinaryData = std::malloc( faultCounts.vendorBinarySize ); + } + result = static_cast( d.vkGetDeviceFaultInfoEXT( + m_device, reinterpret_cast( &faultCounts ), reinterpret_cast( &faultInfo ) ) ); + } + } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFaultInfoEXT", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete } ); - return ResultValue>( - static_cast( result ), data_ ); + return createResultValueType( result, std::move( data_ ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -22652,7 +22692,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast( &display ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" ); - return createResultValueType( result, display ); + return createResultValueType( result, std::move( display ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -22713,7 +22753,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surface ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXT" ); - return createResultValueType( result, surface ); + return createResultValueType( result, std::move( surface ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -22835,7 +22875,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetMemoryZirconHandleFUCHSIA( m_device, reinterpret_cast( &getZirconHandleInfo ), &zirconHandle ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" ); - return createResultValueType( result, zirconHandle ); + return createResultValueType( result, std::move( zirconHandle ) ); } # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -22875,7 +22915,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &memoryZirconHandleProperties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" ); - return createResultValueType( result, memoryZirconHandleProperties ); + return createResultValueType( result, std::move( memoryZirconHandleProperties ) ); } # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /*VK_USE_PLATFORM_FUCHSIA*/ @@ -22937,7 +22977,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetSemaphoreZirconHandleFUCHSIA( m_device, reinterpret_cast( &getZirconHandleInfo ), &zirconHandle ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA" ); - return createResultValueType( result, zirconHandle ); + return createResultValueType( result, std::move( zirconHandle ) ); } # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /*VK_USE_PLATFORM_FUCHSIA*/ @@ -22979,7 +23019,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &collection ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferCollectionFUCHSIA" ); - return createResultValueType( result, collection ); + return createResultValueType( result, std::move( collection ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -23155,7 +23195,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, static_cast( collection ), reinterpret_cast( &properties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getBufferCollectionPropertiesFUCHSIA" ); - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /*VK_USE_PLATFORM_FUCHSIA*/ @@ -23174,8 +23214,8 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue - Device::getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) @@ -23186,11 +23226,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Extent2D maxWorkgroupSize; VULKAN_HPP_NAMESPACE::Result result = static_cast( d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( m_device, static_cast( renderpass ), reinterpret_cast( &maxWorkgroupSize ) ) ); - resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::getSubpassShadingMaxWorkgroupSizeHUAWEI", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete } ); + resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSubpassShadingMaxWorkgroupSizeHUAWEI" ); - return ResultValue( static_cast( result ), maxWorkgroupSize ); + return createResultValueType( result, std::move( maxWorkgroupSize ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -23240,7 +23278,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, reinterpret_cast( &memoryGetRemoteAddressInfo ), reinterpret_cast( &address ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryRemoteAddressNV" ); - return createResultValueType( result, address ); + return createResultValueType( result, std::move( address ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -23271,7 +23309,7 @@ namespace VULKAN_HPP_NAMESPACE m_device, reinterpret_cast( &pipelineInfo ), reinterpret_cast( &pipelineProperties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelinePropertiesEXT" ); - return createResultValueType( result, pipelineProperties ); + return createResultValueType( result, std::move( pipelineProperties ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -23350,7 +23388,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surface ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNX" ); - return createResultValueType( result, surface ); + return createResultValueType( result, std::move( surface ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -23549,7 +23587,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( µmap ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createMicromapEXT" ); - return createResultValueType( result, micromap ); + return createResultValueType( result, std::move( micromap ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -23821,7 +23859,7 @@ namespace VULKAN_HPP_NAMESPACE stride ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeMicromapsPropertiesEXT" ); - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } template @@ -23847,7 +23885,7 @@ namespace VULKAN_HPP_NAMESPACE stride ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeMicromapsPropertyEXT" ); - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -24956,7 +24994,7 @@ namespace VULKAN_HPP_NAMESPACE { imageFormatProperties.resize( formatCount ); } - return createResultValueType( result, imageFormatProperties ); + return createResultValueType( result, std::move( imageFormatProperties ) ); } template ( &session ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createOpticalFlowSessionNV" ); - return createResultValueType( result, session ); + return createResultValueType( result, std::move( session ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -25352,8 +25390,8 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, Optional allocator, Dispatch const & d ) const { @@ -25369,16 +25407,19 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( shaders.data() ) ) ); - resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXT" ); + resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXT", + { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } ); - return createResultValueType( result, shaders ); + return ResultValue>( static_cast( result ), + std::move( shaders ) ); } template ::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, Optional allocator, ShaderEXTAllocator & shaderEXTAllocator, Dispatch const & d ) const @@ -25395,14 +25436,17 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( shaders.data() ) ) ); - resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXT" ); + resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXT", + { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } ); - return createResultValueType( result, shaders ); + return ResultValue>( static_cast( result ), + std::move( shaders ) ); } template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createShaderEXT( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo, + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue + Device::createShaderEXT( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const { @@ -25418,15 +25462,16 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &shader ) ) ); - resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderEXT" ); + resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderEXT", + { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } ); - return createResultValueType( result, shader ); + return ResultValue( static_cast( result ), std::move( shader ) ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType, ShaderEXTAllocator>>::type + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, ShaderEXTAllocator>> Device::createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, Optional allocator, Dispatch const & d ) const @@ -25443,7 +25488,9 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( shaders.data() ) ) ); - resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXTUnique" ); + resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXTUnique", + { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } ); std::vector, ShaderEXTAllocator> uniqueShaders; uniqueShaders.reserve( createInfos.size() ); ObjectDestroy deleter( *this, allocator, d ); @@ -25451,15 +25498,15 @@ namespace VULKAN_HPP_NAMESPACE { uniqueShaders.push_back( UniqueHandle( shader, deleter ) ); } - return createResultValueType( result, std::move( uniqueShaders ) ); + return ResultValue, ShaderEXTAllocator>>( + static_cast( result ), std::move( uniqueShaders ) ); } template < typename Dispatch, typename ShaderEXTAllocator, typename std::enable_if>::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType, ShaderEXTAllocator>>::type + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, ShaderEXTAllocator>> Device::createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, Optional allocator, ShaderEXTAllocator & shaderEXTAllocator, @@ -25477,7 +25524,9 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( shaders.data() ) ) ); - resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXTUnique" ); + resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXTUnique", + { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } ); std::vector, ShaderEXTAllocator> uniqueShaders( shaderEXTAllocator ); uniqueShaders.reserve( createInfos.size() ); ObjectDestroy deleter( *this, allocator, d ); @@ -25485,12 +25534,13 @@ namespace VULKAN_HPP_NAMESPACE { uniqueShaders.push_back( UniqueHandle( shader, deleter ) ); } - return createResultValueType( result, std::move( uniqueShaders ) ); + return ResultValue, ShaderEXTAllocator>>( + static_cast( result ), std::move( uniqueShaders ) ); } template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createShaderEXTUnique( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo, + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createShaderEXTUnique( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const { @@ -25506,10 +25556,13 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &shader ) ) ); - resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderEXTUnique" ); + resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderEXTUnique", + { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } ); - return createResultValueType( result, - UniqueHandle( shader, ObjectDestroy( *this, allocator, d ) ) ); + return ResultValue>( + static_cast( result ), + UniqueHandle( shader, ObjectDestroy( *this, allocator, d ) ) ); } # endif /* VULKAN_HPP_NO_SMART_HANDLE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -25603,7 +25656,7 @@ namespace VULKAN_HPP_NAMESPACE { data.resize( dataSize ); } - return createResultValueType( result, data ); + return createResultValueType( result, std::move( data ) ); } template ( &properties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getScreenBufferPropertiesQNX" ); - return createResultValueType( result, properties ); + return createResultValueType( result, std::move( properties ) ); } template @@ -26059,7 +26112,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetScreenBufferPropertiesQNX( m_device, &buffer, reinterpret_cast( &properties ) ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getScreenBufferPropertiesQNX" ); - return createResultValueType( result, structureChain ); + return createResultValueType( result, std::move( structureChain ) ); } # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ @@ -26116,7 +26169,7 @@ namespace VULKAN_HPP_NAMESPACE { timeDomains.resize( timeDomainCount ); } - return createResultValueType( result, timeDomains ); + return createResultValueType( result, std::move( timeDomains ) ); } template ( timestampInfos.data() ), timestamps.data(), &maxDeviation ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" ); - return createResultValueType( result, data_ ); + return createResultValueType( result, std::move( data_ ) ); } template ( timestampInfos.data() ), timestamps.data(), &maxDeviation ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" ); - return createResultValueType( result, data_ ); + return createResultValueType( result, std::move( data_ ) ); } template @@ -26231,7 +26284,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetCalibratedTimestampsKHR( m_device, 1, reinterpret_cast( ×tampInfo ), ×tamp, &maxDeviation ) ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampKHR" ); - return createResultValueType( result, data_ ); + return createResultValueType( result, std::move( data_ ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ diff --git a/third_party/vulkan/vulkan_handles.hpp b/third_party/vulkan/vulkan_handles.hpp index e6b1481..945bd34 100644 --- a/third_party/vulkan/vulkan_handles.hpp +++ b/third_party/vulkan/vulkan_handles.hpp @@ -1163,6 +1163,11 @@ namespace VULKAN_HPP_NAMESPACE struct MemoryMapInfoKHR; struct MemoryUnmapInfoKHR; + //=== VK_EXT_map_memory_placed === + struct PhysicalDeviceMapMemoryPlacedFeaturesEXT; + struct PhysicalDeviceMapMemoryPlacedPropertiesEXT; + struct MemoryMapPlacedInfoEXT; + //=== VK_EXT_shader_atomic_float2 === struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT; @@ -1815,6 +1820,9 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_NV_descriptor_pool_overallocation === struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV; + //=== VK_NV_shader_atomic_float16_vector === + struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; + //=================================== //=== HANDLE forward declarations === //=================================== @@ -12754,12 +12762,12 @@ namespace VULKAN_HPP_NAMESPACE #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ template - Result unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR * pMemoryUnmapInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NODISCARD Result unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR * pMemoryUnmapInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - void unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + typename ResultValueType::type unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ //=== VK_EXT_swapchain_maintenance1 === @@ -13167,8 +13175,8 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD ResultValue> - getFaultInfoEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getFaultInfoEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #if defined( VK_USE_PLATFORM_FUCHSIA ) @@ -13318,7 +13326,7 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD ResultValue + VULKAN_HPP_NODISCARD typename ResultValueType::type getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -13736,44 +13744,44 @@ namespace VULKAN_HPP_NAMESPACE 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> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, - Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD ResultValue> + createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template , typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, - Optional allocator, - ShaderEXTAllocator & shaderEXTAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD ResultValue> + createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + Optional allocator, + ShaderEXTAllocator & shaderEXTAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template - VULKAN_HPP_NODISCARD typename ResultValueType::type - createShaderEXT( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD ResultValue + createShaderEXT( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE template >> - VULKAN_HPP_NODISCARD typename ResultValueType, ShaderEXTAllocator>>::type - createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, - Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD ResultValue, ShaderEXTAllocator>> + createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template >, typename std::enable_if>::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType, ShaderEXTAllocator>>::type - createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, - Optional allocator, - ShaderEXTAllocator & shaderEXTAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD ResultValue, ShaderEXTAllocator>> + createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + Optional allocator, + ShaderEXTAllocator & shaderEXTAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createShaderEXTUnique( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD ResultValue> + createShaderEXTUnique( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; # endif /* VULKAN_HPP_NO_SMART_HANDLE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ diff --git a/third_party/vulkan/vulkan_hash.hpp b/third_party/vulkan/vulkan_hash.hpp index bebd7cb..7bb3216 100644 --- a/third_party/vulkan/vulkan_hash.hpp +++ b/third_party/vulkan/vulkan_hash.hpp @@ -6815,6 +6815,19 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT const & memoryMapPlacedInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.pPlacedAddress ); + return seed; + } + }; + template <> struct hash { @@ -9683,6 +9696,36 @@ namespace std } }; + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT const & physicalDeviceMapMemoryPlacedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryMapPlaced ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryMapRangePlaced ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryUnmapReserve ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT const & physicalDeviceMapMemoryPlacedPropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.minPlacedMemoryMapAlignment ); + return seed; + } + }; + template <> struct hash { @@ -10949,6 +10992,20 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & physicalDeviceShaderAtomicFloat16VectorFeaturesNV ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.shaderFloat16VectorAtomics ); + return seed; + } + }; + template <> struct hash { diff --git a/third_party/vulkan/vulkan_raii.hpp b/third_party/vulkan/vulkan_raii.hpp index e97bfb3..22cb9c4 100644 --- a/third_party/vulkan/vulkan_raii.hpp +++ b/third_party/vulkan/vulkan_raii.hpp @@ -17,17 +17,17 @@ namespace VULKAN_HPP_NAMESPACE { namespace VULKAN_HPP_RAII_NAMESPACE { +# if ( 14 <= VULKAN_HPP_CPP_VERSION ) + using std::exchange; +# else template VULKAN_HPP_CONSTEXPR_14 VULKAN_HPP_INLINE T exchange( T & obj, U && newValue ) { -# if ( 14 <= VULKAN_HPP_CPP_VERSION ) - return std::exchange( obj, std::forward( newValue ) ); -# else T oldValue = std::move( obj ); obj = std::forward( newValue ); return oldValue; -# endif } +# endif template class CreateReturnType @@ -4311,7 +4311,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD void * mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR & memoryMapInfo ) const; - void unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT; + void unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo ) const; //=== VK_EXT_swapchain_maintenance1 === @@ -4413,9 +4413,7 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_device_fault === - VULKAN_HPP_NODISCARD - std::pair> - getFaultInfoEXT() const; + VULKAN_HPP_NODISCARD std::pair getFaultInfoEXT() const; # if defined( VK_USE_PLATFORM_FUCHSIA ) //=== VK_FUCHSIA_external_memory === @@ -10411,7 +10409,7 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_HUAWEI_subpass_shading === - VULKAN_HPP_NODISCARD std::pair getSubpassShadingMaxWorkgroupSizeHUAWEI() const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D getSubpassShadingMaxWorkgroupSizeHUAWEI() const; private: VULKAN_HPP_NAMESPACE::Device m_device = {}; @@ -10808,10 +10806,12 @@ namespace VULKAN_HPP_NAMESPACE ShaderEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkShaderEXT shader, - VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr, + VULKAN_HPP_NAMESPACE::Result successCode = VULKAN_HPP_NAMESPACE::Result::eSuccess ) : m_device( device ) , m_shader( shader ) , m_allocator( static_cast( allocator ) ) + , m_constructorSuccessCode( successCode ) , m_dispatcher( device.getDispatcher() ) { } @@ -10830,6 +10830,7 @@ namespace VULKAN_HPP_NAMESPACE : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) , m_shader( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_shader, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) + , m_constructorSuccessCode( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_constructorSuccessCode, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { } @@ -10843,6 +10844,7 @@ namespace VULKAN_HPP_NAMESPACE std::swap( m_device, rhs.m_device ); std::swap( m_shader, rhs.m_shader ); std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); std::swap( m_dispatcher, rhs.m_dispatcher ); } return *this; @@ -10865,20 +10867,27 @@ namespace VULKAN_HPP_NAMESPACE getDispatcher()->vkDestroyShaderEXT( static_cast( m_device ), static_cast( m_shader ), reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_shader = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_shader = nullptr; + m_allocator = nullptr; + m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::ShaderEXT release() { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_allocator = nullptr; + m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; + m_dispatcher = nullptr; return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_shader, nullptr ); } + VULKAN_HPP_NAMESPACE::Result getConstructorSuccessCode() const + { + return m_constructorSuccessCode; + } + VULKAN_HPP_NAMESPACE::Device getDevice() const { return m_device; @@ -10895,6 +10904,7 @@ namespace VULKAN_HPP_NAMESPACE std::swap( m_device, rhs.m_device ); std::swap( m_shader, rhs.m_shader ); std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -10903,10 +10913,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD std::vector getBinaryData() const; private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::ShaderEXT m_shader = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::ShaderEXT m_shader = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::Result m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; class ShaderEXTs : public std::vector @@ -12617,7 +12628,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::QueryPool::getResults", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); - return std::make_pair( static_cast( result ), data ); + return std::make_pair( static_cast( result ), std::move( data ) ); } template @@ -12639,7 +12650,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::QueryPool::getResult", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); - return std::make_pair( static_cast( result ), data ); + return std::make_pair( static_cast( result ), std::move( data ) ); } VULKAN_HPP_NODISCARD @@ -15127,7 +15138,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result::eNotReady, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); - return std::make_pair( static_cast( result ), imageIndex ); + return std::make_pair( static_cast( result ), std::move( imageIndex ) ); } VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Queue::presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo ) const @@ -15216,7 +15227,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result::eNotReady, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); - return std::make_pair( static_cast( result ), imageIndex ); + return std::make_pair( static_cast( result ), std::move( imageIndex ) ); } //=== VK_KHR_display === @@ -20223,11 +20234,13 @@ namespace VULKAN_HPP_NAMESPACE return pData; } - VULKAN_HPP_INLINE void Device::unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE void Device::unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo ) const { VULKAN_HPP_ASSERT( getDispatcher()->vkUnmapMemory2KHR && "Function requires " ); - getDispatcher()->vkUnmapMemory2KHR( static_cast( m_device ), reinterpret_cast( &memoryUnmapInfo ) ); + VULKAN_HPP_NAMESPACE::Result result = static_cast( + getDispatcher()->vkUnmapMemory2KHR( static_cast( m_device ), reinterpret_cast( &memoryUnmapInfo ) ) ); + resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::unmapMemory2KHR" ); } //=== VK_EXT_swapchain_maintenance1 === @@ -21047,24 +21060,47 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_device_fault === - VULKAN_HPP_NODISCARD - VULKAN_HPP_INLINE std::pair> - Device::getFaultInfoEXT() const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair + Device::getFaultInfoEXT() const { VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceFaultInfoEXT && "Function requires " ); std::pair data_; VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT & faultCounts = data_.first; VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT & faultInfo = data_.second; - VULKAN_HPP_NAMESPACE::Result result = - static_cast( getDispatcher()->vkGetDeviceFaultInfoEXT( static_cast( m_device ), - reinterpret_cast( &faultCounts ), - reinterpret_cast( &faultInfo ) ) ); + VULKAN_HPP_NAMESPACE::Result result; + do + { + result = static_cast( + getDispatcher()->vkGetDeviceFaultInfoEXT( m_device, reinterpret_cast( &faultCounts ), nullptr ) ); + if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) + { + std::free( faultInfo.pAddressInfos ); + if ( faultCounts.addressInfoCount ) + { + faultInfo.pAddressInfos = reinterpret_cast( + std::malloc( faultCounts.addressInfoCount * sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT ) ) ); + } + std::free( faultInfo.pVendorInfos ); + if ( faultCounts.vendorInfoCount ) + { + faultInfo.pVendorInfos = reinterpret_cast( + std::malloc( faultCounts.vendorInfoCount * sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT ) ) ); + } + std::free( faultInfo.pVendorBinaryData ); + if ( faultCounts.vendorBinarySize ) + { + faultInfo.pVendorBinaryData = std::malloc( faultCounts.vendorBinarySize ); + } + result = static_cast( getDispatcher()->vkGetDeviceFaultInfoEXT( + m_device, reinterpret_cast( &faultCounts ), reinterpret_cast( &faultInfo ) ) ); + } + } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFaultInfoEXT", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete } ); - return std::make_pair( static_cast( result ), data_ ); + return data_; } # if defined( VK_USE_PLATFORM_WIN32_KHR ) @@ -21290,8 +21326,7 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_HUAWEI_subpass_shading === - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair - RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI() const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI() const { VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI && "Function requires " ); @@ -21299,11 +21334,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Extent2D maxWorkgroupSize; VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( static_cast( m_device ), static_cast( m_renderPass ), reinterpret_cast( &maxWorkgroupSize ) ) ); - resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete } ); + resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI" ); - return std::make_pair( static_cast( result ), maxWorkgroupSize ); + return maxWorkgroupSize; } VULKAN_HPP_INLINE void CommandBuffer::subpassShadingHUAWEI() const VULKAN_HPP_NOEXCEPT @@ -22500,7 +22533,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( shaders.data() ) ) ); - if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) + if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT ) ) { # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) return VULKAN_HPP_UNEXPECTED( result ); @@ -22513,7 +22546,7 @@ namespace VULKAN_HPP_NAMESPACE shadersRAII.reserve( shaders.size() ); for ( auto & shader : shaders ) { - shadersRAII.emplace_back( *this, *reinterpret_cast( &shader ), allocator ); + shadersRAII.emplace_back( *this, *reinterpret_cast( &shader ), allocator, result ); } return shadersRAII; } @@ -22530,7 +22563,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &shader ) ) ); - if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) + if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT ) ) { # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) return VULKAN_HPP_UNEXPECTED( result ); diff --git a/third_party/vulkan/vulkan_static_assertions.hpp b/third_party/vulkan/vulkan_static_assertions.hpp index 30f287a..07c3078 100644 --- a/third_party/vulkan/vulkan_static_assertions.hpp +++ b/third_party/vulkan/vulkan_static_assertions.hpp @@ -4666,6 +4666,28 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "MemoryUnmapInfoKHR is not nothrow_move_constructible!" ); +//=== VK_EXT_map_memory_placed === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT ) == sizeof( VkPhysicalDeviceMapMemoryPlacedFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMapMemoryPlacedFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT ) == sizeof( VkPhysicalDeviceMapMemoryPlacedPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMapMemoryPlacedPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT ) == sizeof( VkMemoryMapPlacedInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryMapPlacedInfoEXT is not nothrow_move_constructible!" ); + //=== VK_EXT_shader_atomic_float2 === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT ) == @@ -7452,4 +7474,14 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV is not nothrow_move_constructible!" ); +//=== VK_NV_shader_atomic_float16_vector === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV ) == + sizeof( VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV is not nothrow_move_constructible!" ); + #endif diff --git a/third_party/vulkan/vulkan_structs.hpp b/third_party/vulkan/vulkan_structs.hpp index c18fbe9..93e911a 100644 --- a/third_party/vulkan/vulkan_structs.hpp +++ b/third_party/vulkan/vulkan_structs.hpp @@ -27650,6 +27650,15 @@ namespace VULKAN_HPP_NAMESPACE { } +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceFaultVendorInfoEXT( std::string const & description_, uint64_t vendorFaultCode_ = {}, uint64_t vendorFaultData_ = {} ) + : vendorFaultCode( vendorFaultCode_ ), vendorFaultData( vendorFaultData_ ) + { + VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); + strncpy( description, description_.data(), std::min( description_.size(), VK_MAX_DESCRIPTION_SIZE ) ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + DeviceFaultVendorInfoEXT & operator=( DeviceFaultVendorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -27666,6 +27675,15 @@ namespace VULKAN_HPP_NAMESPACE return *this; } +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceFaultVendorInfoEXT & setDescription( std::string const & description_ ) VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); + strncpy( description, description_.data(), std::min( description_.size(), VK_MAX_DESCRIPTION_SIZE ) ); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT & setVendorFaultCode( uint64_t vendorFaultCode_ ) VULKAN_HPP_NOEXCEPT { vendorFaultCode = vendorFaultCode_; @@ -27702,22 +27720,28 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceFaultVendorInfoEXT const & ) const = default; -#else + std::strong_ordering operator<=>( DeviceFaultVendorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = vendorFaultCode <=> rhs.vendorFaultCode; cmp != 0 ) + return cmp; + if ( auto cmp = vendorFaultData <=> rhs.vendorFaultData; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + bool operator==( DeviceFaultVendorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( description == rhs.description ) && ( vendorFaultCode == rhs.vendorFaultCode ) && ( vendorFaultData == rhs.vendorFaultData ); -# endif + return ( strcmp( description, rhs.description ) == 0 ) && ( vendorFaultCode == rhs.vendorFaultCode ) && ( vendorFaultData == rhs.vendorFaultData ); } bool operator!=( DeviceFaultVendorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -#endif public: VULKAN_HPP_NAMESPACE::ArrayWrapper1D description = {}; @@ -27746,19 +27770,61 @@ namespace VULKAN_HPP_NAMESPACE { } +# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE VULKAN_HPP_CONSTEXPR_14 DeviceFaultInfoEXT( DeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; DeviceFaultInfoEXT( VkDeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DeviceFaultInfoEXT( *reinterpret_cast( &rhs ) ) {} DeviceFaultInfoEXT & operator=( DeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ +# else + DeviceFaultInfoEXT( DeviceFaultInfoEXT const & ) = delete; + DeviceFaultInfoEXT & operator=( DeviceFaultInfoEXT const & ) = delete; - DeviceFaultInfoEXT & operator=( VkDeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + DeviceFaultInfoEXT( DeviceFaultInfoEXT && rhs ) VULKAN_HPP_NOEXCEPT + : pNext( rhs.pNext ) + , pAddressInfos( rhs.pAddressInfos ) + , pVendorInfos( rhs.pVendorInfos ) + , pVendorBinaryData( rhs.pVendorBinaryData ) { - *this = *reinterpret_cast( &rhs ); + memcpy( description, rhs.description, VK_MAX_DESCRIPTION_SIZE ); + + rhs.pNext = nullptr; + memset( rhs.description, 0, VK_MAX_DESCRIPTION_SIZE ); + rhs.pAddressInfos = nullptr; + rhs.pVendorInfos = nullptr; + rhs.pVendorBinaryData = nullptr; + } + + DeviceFaultInfoEXT & operator=( DeviceFaultInfoEXT && rhs ) VULKAN_HPP_NOEXCEPT + { + free( pAddressInfos ); + free( pVendorInfos ); + free( pVendorBinaryData ); + + pNext = rhs.pNext; + memcpy( description, rhs.description, VK_MAX_DESCRIPTION_SIZE ); + pAddressInfos = rhs.pAddressInfos; + pVendorInfos = rhs.pVendorInfos; + pVendorBinaryData = rhs.pVendorBinaryData; + + rhs.pNext = nullptr; + memset( rhs.description, 0, VK_MAX_DESCRIPTION_SIZE ); + rhs.pAddressInfos = nullptr; + rhs.pVendorInfos = nullptr; + rhs.pVendorBinaryData = nullptr; + return *this; } + ~DeviceFaultInfoEXT() VULKAN_HPP_NOEXCEPT + { + free( pAddressInfos ); + free( pVendorInfos ); + free( pVendorBinaryData ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + operator VkDeviceFaultInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); @@ -27787,23 +27853,35 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceFaultInfoEXT const & ) const = default; -#else + std::strong_ordering operator<=>( DeviceFaultInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = pAddressInfos <=> rhs.pAddressInfos; cmp != 0 ) + return cmp; + if ( auto cmp = pVendorInfos <=> rhs.pVendorInfos; cmp != 0 ) + return cmp; + if ( auto cmp = pVendorBinaryData <=> rhs.pVendorBinaryData; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + bool operator==( DeviceFaultInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( description == rhs.description ) && ( pAddressInfos == rhs.pAddressInfos ) && + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( strcmp( description, rhs.description ) == 0 ) && ( pAddressInfos == rhs.pAddressInfos ) && ( pVendorInfos == rhs.pVendorInfos ) && ( pVendorBinaryData == rhs.pVendorBinaryData ); -# endif } bool operator!=( DeviceFaultInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceFaultInfoEXT; @@ -35578,6 +35656,14 @@ namespace VULKAN_HPP_NAMESPACE { } +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ExtensionProperties( std::string const & extensionName_, uint32_t specVersion_ = {} ) : specVersion( specVersion_ ) + { + VULKAN_HPP_ASSERT( extensionName_.size() < VK_MAX_EXTENSION_NAME_SIZE ); + strncpy( extensionName, extensionName_.data(), std::min( extensionName_.size(), VK_MAX_EXTENSION_NAME_SIZE ) ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + ExtensionProperties & operator=( ExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -35610,22 +35696,26 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExtensionProperties const & ) const = default; -#else + std::strong_ordering operator<=>( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = strcmp( extensionName, rhs.extensionName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = specVersion <=> rhs.specVersion; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + bool operator==( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( extensionName == rhs.extensionName ) && ( specVersion == rhs.specVersion ); -# endif + return ( strcmp( extensionName, rhs.extensionName ) == 0 ) && ( specVersion == rhs.specVersion ); } bool operator!=( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -#endif public: VULKAN_HPP_NAMESPACE::ArrayWrapper1D extensionName = {}; @@ -39000,98 +39090,6 @@ namespace VULKAN_HPP_NAMESPACE return *this; } -#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setPresentID( uint64_t presentID_ ) VULKAN_HPP_NOEXCEPT - { - presentID = presentID_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setInputSampleTimeUs( uint64_t inputSampleTimeUs_ ) VULKAN_HPP_NOEXCEPT - { - inputSampleTimeUs = inputSampleTimeUs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setSimStartTimeUs( uint64_t simStartTimeUs_ ) VULKAN_HPP_NOEXCEPT - { - simStartTimeUs = simStartTimeUs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setSimEndTimeUs( uint64_t simEndTimeUs_ ) VULKAN_HPP_NOEXCEPT - { - simEndTimeUs = simEndTimeUs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setRenderSubmitStartTimeUs( uint64_t renderSubmitStartTimeUs_ ) VULKAN_HPP_NOEXCEPT - { - renderSubmitStartTimeUs = renderSubmitStartTimeUs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setRenderSubmitEndTimeUs( uint64_t renderSubmitEndTimeUs_ ) VULKAN_HPP_NOEXCEPT - { - renderSubmitEndTimeUs = renderSubmitEndTimeUs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setPresentStartTimeUs( uint64_t presentStartTimeUs_ ) VULKAN_HPP_NOEXCEPT - { - presentStartTimeUs = presentStartTimeUs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setPresentEndTimeUs( uint64_t presentEndTimeUs_ ) VULKAN_HPP_NOEXCEPT - { - presentEndTimeUs = presentEndTimeUs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setDriverStartTimeUs( uint64_t driverStartTimeUs_ ) VULKAN_HPP_NOEXCEPT - { - driverStartTimeUs = driverStartTimeUs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setDriverEndTimeUs( uint64_t driverEndTimeUs_ ) VULKAN_HPP_NOEXCEPT - { - driverEndTimeUs = driverEndTimeUs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setOsRenderQueueStartTimeUs( uint64_t osRenderQueueStartTimeUs_ ) VULKAN_HPP_NOEXCEPT - { - osRenderQueueStartTimeUs = osRenderQueueStartTimeUs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setOsRenderQueueEndTimeUs( uint64_t osRenderQueueEndTimeUs_ ) VULKAN_HPP_NOEXCEPT - { - osRenderQueueEndTimeUs = osRenderQueueEndTimeUs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setGpuRenderStartTimeUs( uint64_t gpuRenderStartTimeUs_ ) VULKAN_HPP_NOEXCEPT - { - gpuRenderStartTimeUs = gpuRenderStartTimeUs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencyTimingsFrameReportNV & setGpuRenderEndTimeUs( uint64_t gpuRenderEndTimeUs_ ) VULKAN_HPP_NOEXCEPT - { - gpuRenderEndTimeUs = gpuRenderEndTimeUs_; - return *this; - } -#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkLatencyTimingsFrameReportNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); @@ -49672,6 +49670,17 @@ namespace VULKAN_HPP_NAMESPACE LayerProperties( VkLayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT : LayerProperties( *reinterpret_cast( &rhs ) ) {} +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + LayerProperties( std::string const & layerName_, uint32_t specVersion_ = {}, uint32_t implementationVersion_ = {}, std::string const & description_ = {} ) + : specVersion( specVersion_ ), implementationVersion( implementationVersion_ ) + { + VULKAN_HPP_ASSERT( layerName_.size() < VK_MAX_EXTENSION_NAME_SIZE ); + strncpy( layerName, layerName_.data(), std::min( layerName_.size(), VK_MAX_EXTENSION_NAME_SIZE ) ); + VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); + strncpy( description, description_.data(), std::min( description_.size(), VK_MAX_DESCRIPTION_SIZE ) ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + LayerProperties & operator=( LayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -49707,23 +49716,31 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( LayerProperties const & ) const = default; -#else + std::strong_ordering operator<=>( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = strcmp( layerName, rhs.layerName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = specVersion <=> rhs.specVersion; cmp != 0 ) + return cmp; + if ( auto cmp = implementationVersion <=> rhs.implementationVersion; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + bool operator==( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( layerName == rhs.layerName ) && ( specVersion == rhs.specVersion ) && ( implementationVersion == rhs.implementationVersion ) && - ( description == rhs.description ); -# endif + return ( strcmp( layerName, rhs.layerName ) == 0 ) && ( specVersion == rhs.specVersion ) && ( implementationVersion == rhs.implementationVersion ) && + ( strcmp( description, rhs.description ) == 0 ); } bool operator!=( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -#endif public: VULKAN_HPP_NAMESPACE::ArrayWrapper1D layerName = {}; @@ -51648,6 +51665,102 @@ namespace VULKAN_HPP_NAMESPACE using Type = MemoryMapInfoKHR; }; + struct MemoryMapPlacedInfoEXT + { + using NativeType = VkMemoryMapPlacedInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryMapPlacedInfoEXT; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryMapPlacedInfoEXT( void * pPlacedAddress_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , pPlacedAddress( pPlacedAddress_ ) + { + } + + VULKAN_HPP_CONSTEXPR MemoryMapPlacedInfoEXT( MemoryMapPlacedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryMapPlacedInfoEXT( VkMemoryMapPlacedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryMapPlacedInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + MemoryMapPlacedInfoEXT & operator=( MemoryMapPlacedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + MemoryMapPlacedInfoEXT & operator=( VkMemoryMapPlacedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryMapPlacedInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMapPlacedInfoEXT & setPPlacedAddress( void * pPlacedAddress_ ) VULKAN_HPP_NOEXCEPT + { + pPlacedAddress = pPlacedAddress_; + return *this; + } +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkMemoryMapPlacedInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryMapPlacedInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pPlacedAddress ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryMapPlacedInfoEXT const & ) const = default; +#else + bool operator==( MemoryMapPlacedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pPlacedAddress == rhs.pPlacedAddress ); +# endif + } + + bool operator!=( MemoryMapPlacedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryMapPlacedInfoEXT; + const void * pNext = {}; + void * pPlacedAddress = {}; + }; + + template <> + struct CppType + { + using Type = MemoryMapPlacedInfoEXT; + }; + struct MemoryOpaqueCaptureAddressAllocateInfo { using NativeType = VkMemoryOpaqueCaptureAddressAllocateInfo; @@ -55027,6 +55140,23 @@ namespace VULKAN_HPP_NAMESPACE { } +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PerformanceCounterDescriptionKHR( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsKHR flags_, + std::string const & name_, + std::string const & category_ = {}, + std::string const & description_ = {}, + void * pNext_ = nullptr ) + : pNext( pNext_ ), flags( flags_ ) + { + VULKAN_HPP_ASSERT( name_.size() < VK_MAX_DESCRIPTION_SIZE ); + strncpy( name, name_.data(), std::min( name_.size(), VK_MAX_DESCRIPTION_SIZE ) ); + VULKAN_HPP_ASSERT( category_.size() < VK_MAX_DESCRIPTION_SIZE ); + strncpy( category, category_.data(), std::min( category_.size(), VK_MAX_DESCRIPTION_SIZE ) ); + VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); + strncpy( description, description_.data(), std::min( description_.size(), VK_MAX_DESCRIPTION_SIZE ) ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + PerformanceCounterDescriptionKHR & operator=( PerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -55064,23 +55194,35 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PerformanceCounterDescriptionKHR const & ) const = default; -#else + std::strong_ordering operator<=>( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = strcmp( category, rhs.category ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + bool operator==( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( name == rhs.name ) && ( category == rhs.category ) && - ( description == rhs.description ); -# endif + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( strcmp( name, rhs.name ) == 0 ) && + ( strcmp( category, rhs.category ) == 0 ) && ( strcmp( description, rhs.description ) == 0 ); } bool operator!=( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePerformanceCounterDescriptionKHR; @@ -55778,20 +55920,6 @@ namespace VULKAN_HPP_NAMESPACE return *this; } -#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PerformanceValueINTEL & setType( VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL type_ ) VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceValueINTEL & setData( VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL const & data_ ) VULKAN_HPP_NOEXCEPT - { - data = data_; - return *this; - } -#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPerformanceValueINTEL const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); @@ -62499,6 +62627,21 @@ namespace VULKAN_HPP_NAMESPACE { } +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PhysicalDeviceDriverProperties( VULKAN_HPP_NAMESPACE::DriverId driverID_, + std::string const & driverName_, + std::string const & driverInfo_ = {}, + VULKAN_HPP_NAMESPACE::ConformanceVersion conformanceVersion_ = {}, + void * pNext_ = nullptr ) + : pNext( pNext_ ), driverID( driverID_ ), conformanceVersion( conformanceVersion_ ) + { + VULKAN_HPP_ASSERT( driverName_.size() < VK_MAX_DRIVER_NAME_SIZE ); + strncpy( driverName, driverName_.data(), std::min( driverName_.size(), VK_MAX_DRIVER_NAME_SIZE ) ); + VULKAN_HPP_ASSERT( driverInfo_.size() < VK_MAX_DRIVER_INFO_SIZE ); + strncpy( driverInfo, driverInfo_.data(), std::min( driverInfo_.size(), VK_MAX_DRIVER_INFO_SIZE ) ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + PhysicalDeviceDriverProperties & operator=( PhysicalDeviceDriverProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -62536,23 +62679,35 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDriverProperties const & ) const = default; -#else + std::strong_ordering operator<=>( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = driverID <=> rhs.driverID; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( driverName, rhs.driverName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = strcmp( driverInfo, rhs.driverInfo ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = conformanceVersion <=> rhs.conformanceVersion; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + bool operator==( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) && ( driverName == rhs.driverName ) && - ( driverInfo == rhs.driverInfo ) && ( conformanceVersion == rhs.conformanceVersion ); -# endif + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) && ( strcmp( driverName, rhs.driverName ) == 0 ) && + ( strcmp( driverInfo, rhs.driverInfo ) == 0 ) && ( conformanceVersion == rhs.conformanceVersion ); } bool operator!=( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDriverProperties; @@ -67361,6 +67516,19 @@ namespace VULKAN_HPP_NAMESPACE { } +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PhysicalDeviceGroupProperties( VULKAN_HPP_NAMESPACE::ArrayProxy const & physicalDevices_, + VULKAN_HPP_NAMESPACE::Bool32 subsetAllocation_ = {}, + void * pNext_ = nullptr ) + : pNext( pNext_ ) + , physicalDeviceCount( std::min( static_cast( physicalDevices_.size() ), VK_MAX_DEVICE_GROUP_SIZE ) ) + , subsetAllocation( subsetAllocation_ ) + { + VULKAN_HPP_ASSERT( physicalDevices_.size() < VK_MAX_DEVICE_GROUP_SIZE ); + memcpy( physicalDevices, physicalDevices_.data(), physicalDeviceCount * sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice ) ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + PhysicalDeviceGroupProperties & operator=( PhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -67397,23 +67565,37 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceGroupProperties const & ) const = default; -#else + std::strong_ordering operator<=>( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = physicalDeviceCount <=> rhs.physicalDeviceCount; cmp != 0 ) + return cmp; + for ( size_t i = 0; i < physicalDeviceCount; ++i ) + { + if ( auto cmp = physicalDevices[i] <=> rhs.physicalDevices[i]; cmp != 0 ) + return cmp; + } + if ( auto cmp = subsetAllocation <=> rhs.subsetAllocation; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + bool operator==( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) && - ( physicalDevices == rhs.physicalDevices ) && ( subsetAllocation == rhs.subsetAllocation ); -# endif + ( memcmp( physicalDevices, rhs.physicalDevices, physicalDeviceCount * sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice ) ) == 0 ) && + ( subsetAllocation == rhs.subsetAllocation ); } bool operator!=( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceGroupProperties; @@ -71794,6 +71976,211 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceMaintenance6PropertiesKHR; }; + struct PhysicalDeviceMapMemoryPlacedFeaturesEXT + { + using NativeType = VkPhysicalDeviceMapMemoryPlacedFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMapMemoryPlacedFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMapMemoryPlacedFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 memoryMapPlaced_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 memoryMapRangePlaced_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 memoryUnmapReserve_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , memoryMapPlaced( memoryMapPlaced_ ) + , memoryMapRangePlaced( memoryMapRangePlaced_ ) + , memoryUnmapReserve( memoryUnmapReserve_ ) + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMapMemoryPlacedFeaturesEXT( PhysicalDeviceMapMemoryPlacedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMapMemoryPlacedFeaturesEXT( VkPhysicalDeviceMapMemoryPlacedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMapMemoryPlacedFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMapMemoryPlacedFeaturesEXT & operator=( PhysicalDeviceMapMemoryPlacedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + PhysicalDeviceMapMemoryPlacedFeaturesEXT & operator=( VkPhysicalDeviceMapMemoryPlacedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT & setMemoryMapPlaced( VULKAN_HPP_NAMESPACE::Bool32 memoryMapPlaced_ ) VULKAN_HPP_NOEXCEPT + { + memoryMapPlaced = memoryMapPlaced_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT & + setMemoryMapRangePlaced( VULKAN_HPP_NAMESPACE::Bool32 memoryMapRangePlaced_ ) VULKAN_HPP_NOEXCEPT + { + memoryMapRangePlaced = memoryMapRangePlaced_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT & + setMemoryUnmapReserve( VULKAN_HPP_NAMESPACE::Bool32 memoryUnmapReserve_ ) VULKAN_HPP_NOEXCEPT + { + memoryUnmapReserve = memoryUnmapReserve_; + return *this; + } +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkPhysicalDeviceMapMemoryPlacedFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMapMemoryPlacedFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryMapPlaced, memoryMapRangePlaced, memoryUnmapReserve ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMapMemoryPlacedFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceMapMemoryPlacedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryMapPlaced == rhs.memoryMapPlaced ) && + ( memoryMapRangePlaced == rhs.memoryMapRangePlaced ) && ( memoryUnmapReserve == rhs.memoryUnmapReserve ); +# endif + } + + bool operator!=( PhysicalDeviceMapMemoryPlacedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMapMemoryPlacedFeaturesEXT; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 memoryMapPlaced = {}; + VULKAN_HPP_NAMESPACE::Bool32 memoryMapRangePlaced = {}; + VULKAN_HPP_NAMESPACE::Bool32 memoryUnmapReserve = {}; + }; + + template <> + struct CppType + { + using Type = PhysicalDeviceMapMemoryPlacedFeaturesEXT; + }; + + struct PhysicalDeviceMapMemoryPlacedPropertiesEXT + { + using NativeType = VkPhysicalDeviceMapMemoryPlacedPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMapMemoryPlacedPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMapMemoryPlacedPropertiesEXT( VULKAN_HPP_NAMESPACE::DeviceSize minPlacedMemoryMapAlignment_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , minPlacedMemoryMapAlignment( minPlacedMemoryMapAlignment_ ) + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMapMemoryPlacedPropertiesEXT( PhysicalDeviceMapMemoryPlacedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMapMemoryPlacedPropertiesEXT( VkPhysicalDeviceMapMemoryPlacedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMapMemoryPlacedPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMapMemoryPlacedPropertiesEXT & operator=( PhysicalDeviceMapMemoryPlacedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + PhysicalDeviceMapMemoryPlacedPropertiesEXT & operator=( VkPhysicalDeviceMapMemoryPlacedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceMapMemoryPlacedPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMapMemoryPlacedPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minPlacedMemoryMapAlignment ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMapMemoryPlacedPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceMapMemoryPlacedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minPlacedMemoryMapAlignment == rhs.minPlacedMemoryMapAlignment ); +# endif + } + + bool operator!=( PhysicalDeviceMapMemoryPlacedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMapMemoryPlacedPropertiesEXT; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::DeviceSize minPlacedMemoryMapAlignment = {}; + }; + + template <> + struct CppType + { + using Type = PhysicalDeviceMapMemoryPlacedPropertiesEXT; + }; + struct PhysicalDeviceMemoryBudgetPropertiesEXT { using NativeType = VkPhysicalDeviceMemoryBudgetPropertiesEXT; @@ -72190,6 +72577,19 @@ namespace VULKAN_HPP_NAMESPACE { } +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PhysicalDeviceMemoryProperties( VULKAN_HPP_NAMESPACE::ArrayProxy const & memoryTypes_, + VULKAN_HPP_NAMESPACE::ArrayProxy const & memoryHeaps_ = {} ) + : memoryTypeCount( std::min( static_cast( memoryTypes_.size() ), VK_MAX_MEMORY_TYPES ) ) + , memoryHeapCount( std::min( static_cast( memoryHeaps_.size() ), VK_MAX_MEMORY_HEAPS ) ) + { + VULKAN_HPP_ASSERT( memoryTypes_.size() < VK_MAX_MEMORY_TYPES ); + memcpy( memoryTypes, memoryTypes_.data(), memoryTypeCount * sizeof( VULKAN_HPP_NAMESPACE::MemoryType ) ); + VULKAN_HPP_ASSERT( memoryHeaps_.size() < VK_MAX_MEMORY_HEAPS ); + memcpy( memoryHeaps, memoryHeaps_.data(), memoryHeapCount * sizeof( VULKAN_HPP_NAMESPACE::MemoryHeap ) ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + PhysicalDeviceMemoryProperties & operator=( PhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -72225,23 +72625,39 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMemoryProperties const & ) const = default; -#else + std::strong_ordering operator<=>( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = memoryTypeCount <=> rhs.memoryTypeCount; cmp != 0 ) + return cmp; + for ( size_t i = 0; i < memoryTypeCount; ++i ) + { + if ( auto cmp = memoryTypes[i] <=> rhs.memoryTypes[i]; cmp != 0 ) + return cmp; + } + if ( auto cmp = memoryHeapCount <=> rhs.memoryHeapCount; cmp != 0 ) + return cmp; + for ( size_t i = 0; i < memoryHeapCount; ++i ) + { + if ( auto cmp = memoryHeaps[i] <=> rhs.memoryHeaps[i]; cmp != 0 ) + return cmp; + } + + return std::strong_ordering::equivalent; + } +#endif + bool operator==( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( memoryTypeCount == rhs.memoryTypeCount ) && ( memoryTypes == rhs.memoryTypes ) && ( memoryHeapCount == rhs.memoryHeapCount ) && - ( memoryHeaps == rhs.memoryHeaps ); -# endif + return ( memoryTypeCount == rhs.memoryTypeCount ) && + ( memcmp( memoryTypes, rhs.memoryTypes, memoryTypeCount * sizeof( VULKAN_HPP_NAMESPACE::MemoryType ) ) == 0 ) && + ( memoryHeapCount == rhs.memoryHeapCount ) && + ( memcmp( memoryHeaps, rhs.memoryHeaps, memoryHeapCount * sizeof( VULKAN_HPP_NAMESPACE::MemoryHeap ) ) == 0 ); } bool operator!=( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -#endif public: uint32_t memoryTypeCount = {}; @@ -77032,6 +77448,30 @@ namespace VULKAN_HPP_NAMESPACE { } +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PhysicalDeviceProperties( uint32_t apiVersion_, + uint32_t driverVersion_, + uint32_t vendorID_, + uint32_t deviceID_, + VULKAN_HPP_NAMESPACE::PhysicalDeviceType deviceType_, + std::string const & deviceName_, + std::array const & pipelineCacheUUID_ = {}, + VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits limits_ = {}, + VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties sparseProperties_ = {} ) + : apiVersion( apiVersion_ ) + , driverVersion( driverVersion_ ) + , vendorID( vendorID_ ) + , deviceID( deviceID_ ) + , deviceType( deviceType_ ) + , pipelineCacheUUID( pipelineCacheUUID_ ) + , limits( limits_ ) + , sparseProperties( sparseProperties_ ) + { + VULKAN_HPP_ASSERT( deviceName_.size() < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE ); + strncpy( deviceName, deviceName_.data(), std::min( deviceName_.size(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE ) ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + PhysicalDeviceProperties & operator=( PhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -77072,24 +77512,42 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceProperties const & ) const = default; -#else + std::strong_ordering operator<=>( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = apiVersion <=> rhs.apiVersion; cmp != 0 ) + return cmp; + if ( auto cmp = driverVersion <=> rhs.driverVersion; cmp != 0 ) + return cmp; + if ( auto cmp = vendorID <=> rhs.vendorID; cmp != 0 ) + return cmp; + if ( auto cmp = deviceID <=> rhs.deviceID; cmp != 0 ) + return cmp; + if ( auto cmp = deviceType <=> rhs.deviceType; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( deviceName, rhs.deviceName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = pipelineCacheUUID <=> rhs.pipelineCacheUUID; cmp != 0 ) + return cmp; + if ( auto cmp = limits <=> rhs.limits; cmp != 0 ) + return cmp; + if ( auto cmp = sparseProperties <=> rhs.sparseProperties; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + bool operator==( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else return ( apiVersion == rhs.apiVersion ) && ( driverVersion == rhs.driverVersion ) && ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) && - ( deviceType == rhs.deviceType ) && ( deviceName == rhs.deviceName ) && ( pipelineCacheUUID == rhs.pipelineCacheUUID ) && + ( deviceType == rhs.deviceType ) && ( strcmp( deviceName, rhs.deviceName ) == 0 ) && ( pipelineCacheUUID == rhs.pipelineCacheUUID ) && ( limits == rhs.limits ) && ( sparseProperties == rhs.sparseProperties ); -# endif } bool operator!=( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -#endif public: uint32_t apiVersion = {}; @@ -80176,6 +80634,106 @@ namespace VULKAN_HPP_NAMESPACE using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures; + struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV + { + using NativeType = VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 shaderFloat16VectorAtomics_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , shaderFloat16VectorAtomics( shaderFloat16VectorAtomics_ ) + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV( PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV( VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV & + operator=( PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV & operator=( VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV & + setShaderFloat16VectorAtomics( VULKAN_HPP_NAMESPACE::Bool32 shaderFloat16VectorAtomics_ ) VULKAN_HPP_NOEXCEPT + { + shaderFloat16VectorAtomics = shaderFloat16VectorAtomics_; + return *this; + } +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderFloat16VectorAtomics ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFloat16VectorAtomics == rhs.shaderFloat16VectorAtomics ); +# endif + } + + bool operator!=( PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 shaderFloat16VectorAtomics = {}; + }; + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; + }; + struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT { using NativeType = VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT; @@ -86172,6 +86730,26 @@ namespace VULKAN_HPP_NAMESPACE { } +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PhysicalDeviceToolProperties( std::string const & name_, + std::string const & version_ = {}, + VULKAN_HPP_NAMESPACE::ToolPurposeFlags purposes_ = {}, + std::string const & description_ = {}, + std::string const & layer_ = {}, + void * pNext_ = nullptr ) + : pNext( pNext_ ), purposes( purposes_ ) + { + VULKAN_HPP_ASSERT( name_.size() < VK_MAX_EXTENSION_NAME_SIZE ); + strncpy( name, name_.data(), std::min( name_.size(), VK_MAX_EXTENSION_NAME_SIZE ) ); + VULKAN_HPP_ASSERT( version_.size() < VK_MAX_EXTENSION_NAME_SIZE ); + strncpy( version, version_.data(), std::min( version_.size(), VK_MAX_EXTENSION_NAME_SIZE ) ); + VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); + strncpy( description, description_.data(), std::min( description_.size(), VK_MAX_DESCRIPTION_SIZE ) ); + VULKAN_HPP_ASSERT( layer_.size() < VK_MAX_EXTENSION_NAME_SIZE ); + strncpy( layer, layer_.data(), std::min( layer_.size(), VK_MAX_EXTENSION_NAME_SIZE ) ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + PhysicalDeviceToolProperties & operator=( PhysicalDeviceToolProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -86210,23 +86788,37 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceToolProperties const & ) const = default; -#else + std::strong_ordering operator<=>( PhysicalDeviceToolProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = strcmp( version, rhs.version ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = purposes <=> rhs.purposes; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = strcmp( layer, rhs.layer ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + bool operator==( PhysicalDeviceToolProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( name == rhs.name ) && ( version == rhs.version ) && ( purposes == rhs.purposes ) && - ( description == rhs.description ) && ( layer == rhs.layer ); -# endif + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( strcmp( name, rhs.name ) == 0 ) && ( strcmp( version, rhs.version ) == 0 ) && + ( purposes == rhs.purposes ) && ( strcmp( description, rhs.description ) == 0 ) && ( strcmp( layer, rhs.layer ) == 0 ); } bool operator!=( PhysicalDeviceToolProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceToolProperties; @@ -88724,6 +89316,120 @@ namespace VULKAN_HPP_NAMESPACE { } +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PhysicalDeviceVulkan12Properties( + VULKAN_HPP_NAMESPACE::DriverId driverID_, + std::string const & driverName_, + std::string const & driverInfo_ = {}, + VULKAN_HPP_NAMESPACE::ConformanceVersion conformanceVersion_ = {}, + VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence denormBehaviorIndependence_ = VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence::e32BitOnly, + VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence roundingModeIndependence_ = VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence::e32BitOnly, + VULKAN_HPP_NAMESPACE::Bool32 shaderSignedZeroInfNanPreserveFloat16_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderSignedZeroInfNanPreserveFloat32_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderSignedZeroInfNanPreserveFloat64_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderDenormPreserveFloat16_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderDenormPreserveFloat32_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderDenormPreserveFloat64_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderDenormFlushToZeroFloat16_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderDenormFlushToZeroFloat32_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderDenormFlushToZeroFloat64_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderRoundingModeRTEFloat16_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderRoundingModeRTEFloat32_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderRoundingModeRTEFloat64_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderRoundingModeRTZFloat16_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderRoundingModeRTZFloat32_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderRoundingModeRTZFloat64_ = {}, + uint32_t maxUpdateAfterBindDescriptorsInAllPools_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderUniformBufferArrayNonUniformIndexingNative_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderSampledImageArrayNonUniformIndexingNative_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderStorageBufferArrayNonUniformIndexingNative_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderStorageImageArrayNonUniformIndexingNative_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderInputAttachmentArrayNonUniformIndexingNative_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccessUpdateAfterBind_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 quadDivergentImplicitLod_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments_ = {}, + uint32_t maxPerStageUpdateAfterBindResources_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindSamplers_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindSampledImages_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindStorageImages_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments_ = {}, + VULKAN_HPP_NAMESPACE::ResolveModeFlags supportedDepthResolveModes_ = {}, + VULKAN_HPP_NAMESPACE::ResolveModeFlags supportedStencilResolveModes_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 independentResolveNone_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 independentResolve_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 filterMinmaxSingleComponentFormats_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 filterMinmaxImageComponentMapping_ = {}, + uint64_t maxTimelineSemaphoreValueDifference_ = {}, + VULKAN_HPP_NAMESPACE::SampleCountFlags framebufferIntegerColorSampleCounts_ = {}, + void * pNext_ = nullptr ) + : pNext( pNext_ ) + , driverID( driverID_ ) + , conformanceVersion( conformanceVersion_ ) + , denormBehaviorIndependence( denormBehaviorIndependence_ ) + , roundingModeIndependence( roundingModeIndependence_ ) + , shaderSignedZeroInfNanPreserveFloat16( shaderSignedZeroInfNanPreserveFloat16_ ) + , shaderSignedZeroInfNanPreserveFloat32( shaderSignedZeroInfNanPreserveFloat32_ ) + , shaderSignedZeroInfNanPreserveFloat64( shaderSignedZeroInfNanPreserveFloat64_ ) + , shaderDenormPreserveFloat16( shaderDenormPreserveFloat16_ ) + , shaderDenormPreserveFloat32( shaderDenormPreserveFloat32_ ) + , shaderDenormPreserveFloat64( shaderDenormPreserveFloat64_ ) + , shaderDenormFlushToZeroFloat16( shaderDenormFlushToZeroFloat16_ ) + , shaderDenormFlushToZeroFloat32( shaderDenormFlushToZeroFloat32_ ) + , shaderDenormFlushToZeroFloat64( shaderDenormFlushToZeroFloat64_ ) + , shaderRoundingModeRTEFloat16( shaderRoundingModeRTEFloat16_ ) + , shaderRoundingModeRTEFloat32( shaderRoundingModeRTEFloat32_ ) + , shaderRoundingModeRTEFloat64( shaderRoundingModeRTEFloat64_ ) + , shaderRoundingModeRTZFloat16( shaderRoundingModeRTZFloat16_ ) + , shaderRoundingModeRTZFloat32( shaderRoundingModeRTZFloat32_ ) + , shaderRoundingModeRTZFloat64( shaderRoundingModeRTZFloat64_ ) + , maxUpdateAfterBindDescriptorsInAllPools( maxUpdateAfterBindDescriptorsInAllPools_ ) + , shaderUniformBufferArrayNonUniformIndexingNative( shaderUniformBufferArrayNonUniformIndexingNative_ ) + , shaderSampledImageArrayNonUniformIndexingNative( shaderSampledImageArrayNonUniformIndexingNative_ ) + , shaderStorageBufferArrayNonUniformIndexingNative( shaderStorageBufferArrayNonUniformIndexingNative_ ) + , shaderStorageImageArrayNonUniformIndexingNative( shaderStorageImageArrayNonUniformIndexingNative_ ) + , shaderInputAttachmentArrayNonUniformIndexingNative( shaderInputAttachmentArrayNonUniformIndexingNative_ ) + , robustBufferAccessUpdateAfterBind( robustBufferAccessUpdateAfterBind_ ) + , quadDivergentImplicitLod( quadDivergentImplicitLod_ ) + , maxPerStageDescriptorUpdateAfterBindSamplers( maxPerStageDescriptorUpdateAfterBindSamplers_ ) + , maxPerStageDescriptorUpdateAfterBindUniformBuffers( maxPerStageDescriptorUpdateAfterBindUniformBuffers_ ) + , maxPerStageDescriptorUpdateAfterBindStorageBuffers( maxPerStageDescriptorUpdateAfterBindStorageBuffers_ ) + , maxPerStageDescriptorUpdateAfterBindSampledImages( maxPerStageDescriptorUpdateAfterBindSampledImages_ ) + , maxPerStageDescriptorUpdateAfterBindStorageImages( maxPerStageDescriptorUpdateAfterBindStorageImages_ ) + , maxPerStageDescriptorUpdateAfterBindInputAttachments( maxPerStageDescriptorUpdateAfterBindInputAttachments_ ) + , maxPerStageUpdateAfterBindResources( maxPerStageUpdateAfterBindResources_ ) + , maxDescriptorSetUpdateAfterBindSamplers( maxDescriptorSetUpdateAfterBindSamplers_ ) + , maxDescriptorSetUpdateAfterBindUniformBuffers( maxDescriptorSetUpdateAfterBindUniformBuffers_ ) + , maxDescriptorSetUpdateAfterBindUniformBuffersDynamic( maxDescriptorSetUpdateAfterBindUniformBuffersDynamic_ ) + , maxDescriptorSetUpdateAfterBindStorageBuffers( maxDescriptorSetUpdateAfterBindStorageBuffers_ ) + , maxDescriptorSetUpdateAfterBindStorageBuffersDynamic( maxDescriptorSetUpdateAfterBindStorageBuffersDynamic_ ) + , maxDescriptorSetUpdateAfterBindSampledImages( maxDescriptorSetUpdateAfterBindSampledImages_ ) + , maxDescriptorSetUpdateAfterBindStorageImages( maxDescriptorSetUpdateAfterBindStorageImages_ ) + , maxDescriptorSetUpdateAfterBindInputAttachments( maxDescriptorSetUpdateAfterBindInputAttachments_ ) + , supportedDepthResolveModes( supportedDepthResolveModes_ ) + , supportedStencilResolveModes( supportedStencilResolveModes_ ) + , independentResolveNone( independentResolveNone_ ) + , independentResolve( independentResolve_ ) + , filterMinmaxSingleComponentFormats( filterMinmaxSingleComponentFormats_ ) + , filterMinmaxImageComponentMapping( filterMinmaxImageComponentMapping_ ) + , maxTimelineSemaphoreValueDifference( maxTimelineSemaphoreValueDifference_ ) + , framebufferIntegerColorSampleCounts( framebufferIntegerColorSampleCounts_ ) + { + VULKAN_HPP_ASSERT( driverName_.size() < VK_MAX_DRIVER_NAME_SIZE ); + strncpy( driverName, driverName_.data(), std::min( driverName_.size(), VK_MAX_DRIVER_NAME_SIZE ) ); + VULKAN_HPP_ASSERT( driverInfo_.size() < VK_MAX_DRIVER_INFO_SIZE ); + strncpy( driverInfo, driverInfo_.data(), std::min( driverInfo_.size(), VK_MAX_DRIVER_INFO_SIZE ) ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + PhysicalDeviceVulkan12Properties & operator=( PhysicalDeviceVulkan12Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -88862,15 +89568,125 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVulkan12Properties const & ) const = default; -#else + std::strong_ordering operator<=>( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = driverID <=> rhs.driverID; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( driverName, rhs.driverName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = strcmp( driverInfo, rhs.driverInfo ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = conformanceVersion <=> rhs.conformanceVersion; cmp != 0 ) + return cmp; + if ( auto cmp = denormBehaviorIndependence <=> rhs.denormBehaviorIndependence; cmp != 0 ) + return cmp; + if ( auto cmp = roundingModeIndependence <=> rhs.roundingModeIndependence; cmp != 0 ) + return cmp; + if ( auto cmp = shaderSignedZeroInfNanPreserveFloat16 <=> rhs.shaderSignedZeroInfNanPreserveFloat16; cmp != 0 ) + return cmp; + if ( auto cmp = shaderSignedZeroInfNanPreserveFloat32 <=> rhs.shaderSignedZeroInfNanPreserveFloat32; cmp != 0 ) + return cmp; + if ( auto cmp = shaderSignedZeroInfNanPreserveFloat64 <=> rhs.shaderSignedZeroInfNanPreserveFloat64; cmp != 0 ) + return cmp; + if ( auto cmp = shaderDenormPreserveFloat16 <=> rhs.shaderDenormPreserveFloat16; cmp != 0 ) + return cmp; + if ( auto cmp = shaderDenormPreserveFloat32 <=> rhs.shaderDenormPreserveFloat32; cmp != 0 ) + return cmp; + if ( auto cmp = shaderDenormPreserveFloat64 <=> rhs.shaderDenormPreserveFloat64; cmp != 0 ) + return cmp; + if ( auto cmp = shaderDenormFlushToZeroFloat16 <=> rhs.shaderDenormFlushToZeroFloat16; cmp != 0 ) + return cmp; + if ( auto cmp = shaderDenormFlushToZeroFloat32 <=> rhs.shaderDenormFlushToZeroFloat32; cmp != 0 ) + return cmp; + if ( auto cmp = shaderDenormFlushToZeroFloat64 <=> rhs.shaderDenormFlushToZeroFloat64; cmp != 0 ) + return cmp; + if ( auto cmp = shaderRoundingModeRTEFloat16 <=> rhs.shaderRoundingModeRTEFloat16; cmp != 0 ) + return cmp; + if ( auto cmp = shaderRoundingModeRTEFloat32 <=> rhs.shaderRoundingModeRTEFloat32; cmp != 0 ) + return cmp; + if ( auto cmp = shaderRoundingModeRTEFloat64 <=> rhs.shaderRoundingModeRTEFloat64; cmp != 0 ) + return cmp; + if ( auto cmp = shaderRoundingModeRTZFloat16 <=> rhs.shaderRoundingModeRTZFloat16; cmp != 0 ) + return cmp; + if ( auto cmp = shaderRoundingModeRTZFloat32 <=> rhs.shaderRoundingModeRTZFloat32; cmp != 0 ) + return cmp; + if ( auto cmp = shaderRoundingModeRTZFloat64 <=> rhs.shaderRoundingModeRTZFloat64; cmp != 0 ) + return cmp; + if ( auto cmp = maxUpdateAfterBindDescriptorsInAllPools <=> rhs.maxUpdateAfterBindDescriptorsInAllPools; cmp != 0 ) + return cmp; + if ( auto cmp = shaderUniformBufferArrayNonUniformIndexingNative <=> rhs.shaderUniformBufferArrayNonUniformIndexingNative; cmp != 0 ) + return cmp; + if ( auto cmp = shaderSampledImageArrayNonUniformIndexingNative <=> rhs.shaderSampledImageArrayNonUniformIndexingNative; cmp != 0 ) + return cmp; + if ( auto cmp = shaderStorageBufferArrayNonUniformIndexingNative <=> rhs.shaderStorageBufferArrayNonUniformIndexingNative; cmp != 0 ) + return cmp; + if ( auto cmp = shaderStorageImageArrayNonUniformIndexingNative <=> rhs.shaderStorageImageArrayNonUniformIndexingNative; cmp != 0 ) + return cmp; + if ( auto cmp = shaderInputAttachmentArrayNonUniformIndexingNative <=> rhs.shaderInputAttachmentArrayNonUniformIndexingNative; cmp != 0 ) + return cmp; + if ( auto cmp = robustBufferAccessUpdateAfterBind <=> rhs.robustBufferAccessUpdateAfterBind; cmp != 0 ) + return cmp; + if ( auto cmp = quadDivergentImplicitLod <=> rhs.quadDivergentImplicitLod; cmp != 0 ) + return cmp; + if ( auto cmp = maxPerStageDescriptorUpdateAfterBindSamplers <=> rhs.maxPerStageDescriptorUpdateAfterBindSamplers; cmp != 0 ) + return cmp; + if ( auto cmp = maxPerStageDescriptorUpdateAfterBindUniformBuffers <=> rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers; cmp != 0 ) + return cmp; + if ( auto cmp = maxPerStageDescriptorUpdateAfterBindStorageBuffers <=> rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers; cmp != 0 ) + return cmp; + if ( auto cmp = maxPerStageDescriptorUpdateAfterBindSampledImages <=> rhs.maxPerStageDescriptorUpdateAfterBindSampledImages; cmp != 0 ) + return cmp; + if ( auto cmp = maxPerStageDescriptorUpdateAfterBindStorageImages <=> rhs.maxPerStageDescriptorUpdateAfterBindStorageImages; cmp != 0 ) + return cmp; + if ( auto cmp = maxPerStageDescriptorUpdateAfterBindInputAttachments <=> rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments; cmp != 0 ) + return cmp; + if ( auto cmp = maxPerStageUpdateAfterBindResources <=> rhs.maxPerStageUpdateAfterBindResources; cmp != 0 ) + return cmp; + if ( auto cmp = maxDescriptorSetUpdateAfterBindSamplers <=> rhs.maxDescriptorSetUpdateAfterBindSamplers; cmp != 0 ) + return cmp; + if ( auto cmp = maxDescriptorSetUpdateAfterBindUniformBuffers <=> rhs.maxDescriptorSetUpdateAfterBindUniformBuffers; cmp != 0 ) + return cmp; + if ( auto cmp = maxDescriptorSetUpdateAfterBindUniformBuffersDynamic <=> rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; cmp != 0 ) + return cmp; + if ( auto cmp = maxDescriptorSetUpdateAfterBindStorageBuffers <=> rhs.maxDescriptorSetUpdateAfterBindStorageBuffers; cmp != 0 ) + return cmp; + if ( auto cmp = maxDescriptorSetUpdateAfterBindStorageBuffersDynamic <=> rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; cmp != 0 ) + return cmp; + if ( auto cmp = maxDescriptorSetUpdateAfterBindSampledImages <=> rhs.maxDescriptorSetUpdateAfterBindSampledImages; cmp != 0 ) + return cmp; + if ( auto cmp = maxDescriptorSetUpdateAfterBindStorageImages <=> rhs.maxDescriptorSetUpdateAfterBindStorageImages; cmp != 0 ) + return cmp; + if ( auto cmp = maxDescriptorSetUpdateAfterBindInputAttachments <=> rhs.maxDescriptorSetUpdateAfterBindInputAttachments; cmp != 0 ) + return cmp; + if ( auto cmp = supportedDepthResolveModes <=> rhs.supportedDepthResolveModes; cmp != 0 ) + return cmp; + if ( auto cmp = supportedStencilResolveModes <=> rhs.supportedStencilResolveModes; cmp != 0 ) + return cmp; + if ( auto cmp = independentResolveNone <=> rhs.independentResolveNone; cmp != 0 ) + return cmp; + if ( auto cmp = independentResolve <=> rhs.independentResolve; cmp != 0 ) + return cmp; + if ( auto cmp = filterMinmaxSingleComponentFormats <=> rhs.filterMinmaxSingleComponentFormats; cmp != 0 ) + return cmp; + if ( auto cmp = filterMinmaxImageComponentMapping <=> rhs.filterMinmaxImageComponentMapping; cmp != 0 ) + return cmp; + if ( auto cmp = maxTimelineSemaphoreValueDifference <=> rhs.maxTimelineSemaphoreValueDifference; cmp != 0 ) + return cmp; + if ( auto cmp = framebufferIntegerColorSampleCounts <=> rhs.framebufferIntegerColorSampleCounts; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + bool operator==( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) && ( driverName == rhs.driverName ) && - ( driverInfo == rhs.driverInfo ) && ( conformanceVersion == rhs.conformanceVersion ) && + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) && ( strcmp( driverName, rhs.driverName ) == 0 ) && + ( strcmp( driverInfo, rhs.driverInfo ) == 0 ) && ( conformanceVersion == rhs.conformanceVersion ) && ( denormBehaviorIndependence == rhs.denormBehaviorIndependence ) && ( roundingModeIndependence == rhs.roundingModeIndependence ) && ( shaderSignedZeroInfNanPreserveFloat16 == rhs.shaderSignedZeroInfNanPreserveFloat16 ) && ( shaderSignedZeroInfNanPreserveFloat32 == rhs.shaderSignedZeroInfNanPreserveFloat32 ) && @@ -88910,14 +89726,12 @@ namespace VULKAN_HPP_NAMESPACE ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping ) && ( maxTimelineSemaphoreValueDifference == rhs.maxTimelineSemaphoreValueDifference ) && ( framebufferIntegerColorSampleCounts == rhs.framebufferIntegerColorSampleCounts ); -# endif } bool operator!=( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVulkan12Properties; @@ -91909,13 +92723,17 @@ namespace VULKAN_HPP_NAMESPACE # if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) template - PipelineExecutableInternalRepresentationKHR( std::array const & name_, - std::array const & description_, - VULKAN_HPP_NAMESPACE::Bool32 isText_, - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & data_, - void * pNext_ = nullptr ) - : pNext( pNext_ ), name( name_ ), description( description_ ), isText( isText_ ), dataSize( data_.size() * sizeof( T ) ), pData( data_.data() ) + PipelineExecutableInternalRepresentationKHR( std::string const & name_, + std::string const & description_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 isText_ = {}, + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & data_ = {}, + void * pNext_ = nullptr ) + : pNext( pNext_ ), isText( isText_ ), dataSize( data_.size() * sizeof( T ) ), pData( data_.data() ) { + VULKAN_HPP_ASSERT( name_.size() < VK_MAX_DESCRIPTION_SIZE ); + strncpy( name, name_.data(), std::min( name_.size(), VK_MAX_DESCRIPTION_SIZE ) ); + VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); + strncpy( description, description_.data(), std::min( description_.size(), VK_MAX_DESCRIPTION_SIZE ) ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -91957,23 +92775,37 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineExecutableInternalRepresentationKHR const & ) const = default; -#else + std::strong_ordering operator<=>( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = isText <=> rhs.isText; cmp != 0 ) + return cmp; + if ( auto cmp = dataSize <=> rhs.dataSize; cmp != 0 ) + return cmp; + if ( auto cmp = pData <=> rhs.pData; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + bool operator==( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( name == rhs.name ) && ( description == rhs.description ) && ( isText == rhs.isText ) && - ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); -# endif + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( strcmp( name, rhs.name ) == 0 ) && ( strcmp( description, rhs.description ) == 0 ) && + ( isText == rhs.isText ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); } bool operator!=( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutableInternalRepresentationKHR; @@ -92019,6 +92851,21 @@ namespace VULKAN_HPP_NAMESPACE { } +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineExecutablePropertiesKHR( VULKAN_HPP_NAMESPACE::ShaderStageFlags stages_, + std::string const & name_, + std::string const & description_ = {}, + uint32_t subgroupSize_ = {}, + void * pNext_ = nullptr ) + : pNext( pNext_ ), stages( stages_ ), subgroupSize( subgroupSize_ ) + { + VULKAN_HPP_ASSERT( name_.size() < VK_MAX_DESCRIPTION_SIZE ); + strncpy( name, name_.data(), std::min( name_.size(), VK_MAX_DESCRIPTION_SIZE ) ); + VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); + strncpy( description, description_.data(), std::min( description_.size(), VK_MAX_DESCRIPTION_SIZE ) ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + PipelineExecutablePropertiesKHR & operator=( PipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -92056,23 +92903,35 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineExecutablePropertiesKHR const & ) const = default; -#else + std::strong_ordering operator<=>( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = stages <=> rhs.stages; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = subgroupSize <=> rhs.subgroupSize; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + bool operator==( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stages == rhs.stages ) && ( name == rhs.name ) && ( description == rhs.description ) && - ( subgroupSize == rhs.subgroupSize ); -# endif + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stages == rhs.stages ) && ( strcmp( name, rhs.name ) == 0 ) && + ( strcmp( description, rhs.description ) == 0 ) && ( subgroupSize == rhs.subgroupSize ); } bool operator!=( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutablePropertiesKHR; @@ -92181,6 +93040,22 @@ namespace VULKAN_HPP_NAMESPACE { } +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineExecutableStatisticKHR( + std::string const & name_, + std::string const & description_ = {}, + VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR format_ = VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR::eBool32, + VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR value_ = {}, + void * pNext_ = nullptr ) + : pNext( pNext_ ), format( format_ ), value( value_ ) + { + VULKAN_HPP_ASSERT( name_.size() < VK_MAX_DESCRIPTION_SIZE ); + strncpy( name, name_.data(), std::min( name_.size(), VK_MAX_DESCRIPTION_SIZE ) ); + VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); + strncpy( description, description_.data(), std::min( description_.size(), VK_MAX_DESCRIPTION_SIZE ) ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + PipelineExecutableStatisticKHR & operator=( PipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -98621,6 +99496,16 @@ namespace VULKAN_HPP_NAMESPACE { } +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + QueueFamilyGlobalPriorityPropertiesKHR( VULKAN_HPP_NAMESPACE::ArrayProxy const & priorities_, + void * pNext_ = nullptr ) + : pNext( pNext_ ), priorityCount( std::min( static_cast( priorities_.size() ), VK_MAX_GLOBAL_PRIORITY_SIZE_KHR ) ) + { + VULKAN_HPP_ASSERT( priorities_.size() < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR ); + memcpy( priorities, priorities_.data(), priorityCount * sizeof( VULKAN_HPP_NAMESPACE::QueueGlobalPriorityKHR ) ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + QueueFamilyGlobalPriorityPropertiesKHR & operator=( QueueFamilyGlobalPriorityPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -98630,27 +99515,6 @@ namespace VULKAN_HPP_NAMESPACE return *this; } -#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 QueueFamilyGlobalPriorityPropertiesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 QueueFamilyGlobalPriorityPropertiesKHR & setPriorityCount( uint32_t priorityCount_ ) VULKAN_HPP_NOEXCEPT - { - priorityCount = priorityCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 QueueFamilyGlobalPriorityPropertiesKHR & - setPriorities( std::array priorities_ ) VULKAN_HPP_NOEXCEPT - { - priorities = priorities_; - return *this; - } -#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkQueueFamilyGlobalPriorityPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); @@ -98677,22 +99541,34 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( QueueFamilyGlobalPriorityPropertiesKHR const & ) const = default; -#else + std::strong_ordering operator<=>( QueueFamilyGlobalPriorityPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = priorityCount <=> rhs.priorityCount; cmp != 0 ) + return cmp; + for ( size_t i = 0; i < priorityCount; ++i ) + { + if ( auto cmp = priorities[i] <=> rhs.priorities[i]; cmp != 0 ) + return cmp; + } + + return std::strong_ordering::equivalent; + } +#endif + bool operator==( QueueFamilyGlobalPriorityPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priorityCount == rhs.priorityCount ) && ( priorities == rhs.priorities ); -# endif + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priorityCount == rhs.priorityCount ) && + ( memcmp( priorities, rhs.priorities, priorityCount * sizeof( VULKAN_HPP_NAMESPACE::QueueGlobalPriorityKHR ) ) == 0 ); } bool operator!=( QueueFamilyGlobalPriorityPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eQueueFamilyGlobalPriorityPropertiesKHR; @@ -103221,6 +104097,17 @@ namespace VULKAN_HPP_NAMESPACE { } +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassSubpassFeedbackInfoEXT( VULKAN_HPP_NAMESPACE::SubpassMergeStatusEXT subpassMergeStatus_, + std::string const & description_, + uint32_t postMergeIndex_ = {} ) + : subpassMergeStatus( subpassMergeStatus_ ), postMergeIndex( postMergeIndex_ ) + { + VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); + strncpy( description, description_.data(), std::min( description_.size(), VK_MAX_DESCRIPTION_SIZE ) ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + RenderPassSubpassFeedbackInfoEXT & operator=( RenderPassSubpassFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -103254,22 +104141,28 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassSubpassFeedbackInfoEXT const & ) const = default; -#else + std::strong_ordering operator<=>( RenderPassSubpassFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = subpassMergeStatus <=> rhs.subpassMergeStatus; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = postMergeIndex <=> rhs.postMergeIndex; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + bool operator==( RenderPassSubpassFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( subpassMergeStatus == rhs.subpassMergeStatus ) && ( description == rhs.description ) && ( postMergeIndex == rhs.postMergeIndex ); -# endif + return ( subpassMergeStatus == rhs.subpassMergeStatus ) && ( strcmp( description, rhs.description ) == 0 ) && ( postMergeIndex == rhs.postMergeIndex ); } bool operator!=( RenderPassSubpassFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -#endif public: VULKAN_HPP_NAMESPACE::SubpassMergeStatusEXT subpassMergeStatus = VULKAN_HPP_NAMESPACE::SubpassMergeStatusEXT::eMerged; @@ -108050,6 +108943,15 @@ namespace VULKAN_HPP_NAMESPACE { } +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & identifier_, void * pNext_ = nullptr ) + : pNext( pNext_ ), identifierSize( std::min( static_cast( identifier_.size() ), VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT ) ) + { + VULKAN_HPP_ASSERT( identifier_.size() < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT ); + memcpy( identifier, identifier_.data(), identifierSize * sizeof( uint8_t ) ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + ShaderModuleIdentifierEXT & operator=( ShaderModuleIdentifierEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -108085,22 +108987,34 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ShaderModuleIdentifierEXT const & ) const = default; -#else + std::strong_ordering operator<=>( ShaderModuleIdentifierEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = identifierSize <=> rhs.identifierSize; cmp != 0 ) + return cmp; + for ( size_t i = 0; i < identifierSize; ++i ) + { + if ( auto cmp = identifier[i] <=> rhs.identifier[i]; cmp != 0 ) + return cmp; + } + + return std::strong_ordering::equivalent; + } +#endif + bool operator==( ShaderModuleIdentifierEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( identifierSize == rhs.identifierSize ) && ( identifier == rhs.identifier ); -# endif + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( identifierSize == rhs.identifierSize ) && + ( memcmp( identifier, rhs.identifier, identifierSize * sizeof( uint8_t ) ) == 0 ); } bool operator!=( ShaderModuleIdentifierEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -#endif public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eShaderModuleIdentifierEXT; @@ -110021,6 +110935,26 @@ namespace VULKAN_HPP_NAMESPACE return *this; } +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SubpassShadingPipelineCreateInfoHUAWEI & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassShadingPipelineCreateInfoHUAWEI & setRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass_ ) VULKAN_HPP_NOEXCEPT + { + renderPass = renderPass_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassShadingPipelineCreateInfoHUAWEI & setSubpass( uint32_t subpass_ ) VULKAN_HPP_NOEXCEPT + { + subpass = subpass_; + return *this; + } +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + operator VkSubpassShadingPipelineCreateInfoHUAWEI const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); diff --git a/third_party/vulkan/vulkan_to_string.hpp b/third_party/vulkan/vulkan_to_string.hpp index b7c08c7..cb3ae0d 100644 --- a/third_party/vulkan/vulkan_to_string.hpp +++ b/third_party/vulkan/vulkan_to_string.hpp @@ -382,9 +382,16 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } - VULKAN_HPP_INLINE std::string to_string( MemoryMapFlags ) + VULKAN_HPP_INLINE std::string to_string( MemoryMapFlags value ) { - return "{}"; + if ( !value ) + return "{}"; + + std::string result; + if ( value & MemoryMapFlagBits::ePlacedEXT ) + result += "PlacedEXT | "; + + return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } VULKAN_HPP_INLINE std::string to_string( ImageAspectFlags value ) @@ -2810,9 +2817,16 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_map_memory2 === - VULKAN_HPP_INLINE std::string to_string( MemoryUnmapFlagsKHR ) + VULKAN_HPP_INLINE std::string to_string( MemoryUnmapFlagsKHR value ) { - return "{}"; + if ( !value ) + return "{}"; + + std::string result; + if ( value & MemoryUnmapFlagBitsKHR::eReserveEXT ) + result += "ReserveEXT | "; + + return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } //=== VK_EXT_surface_maintenance1 === @@ -3579,7 +3593,7 @@ namespace VULKAN_HPP_NAMESPACE case Result::eOperationNotDeferredKHR: return "OperationNotDeferredKHR"; case Result::eErrorInvalidVideoStdParametersKHR: return "ErrorInvalidVideoStdParametersKHR"; case Result::eErrorCompressionExhaustedEXT: return "ErrorCompressionExhaustedEXT"; - case Result::eErrorIncompatibleShaderBinaryEXT: return "ErrorIncompatibleShaderBinaryEXT"; + case Result::eIncompatibleShaderBinaryEXT: return "IncompatibleShaderBinaryEXT"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -4184,6 +4198,9 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eHostImageCopyDevicePerformanceQueryEXT: return "HostImageCopyDevicePerformanceQueryEXT"; case StructureType::eMemoryMapInfoKHR: return "MemoryMapInfoKHR"; case StructureType::eMemoryUnmapInfoKHR: return "MemoryUnmapInfoKHR"; + case StructureType::ePhysicalDeviceMapMemoryPlacedFeaturesEXT: return "PhysicalDeviceMapMemoryPlacedFeaturesEXT"; + case StructureType::ePhysicalDeviceMapMemoryPlacedPropertiesEXT: return "PhysicalDeviceMapMemoryPlacedPropertiesEXT"; + case StructureType::eMemoryMapPlacedInfoEXT: return "MemoryMapPlacedInfoEXT"; case StructureType::ePhysicalDeviceShaderAtomicFloat2FeaturesEXT: return "PhysicalDeviceShaderAtomicFloat2FeaturesEXT"; case StructureType::eSurfacePresentModeEXT: return "SurfacePresentModeEXT"; case StructureType::eSurfacePresentScalingCapabilitiesEXT: return "SurfacePresentScalingCapabilitiesEXT"; @@ -4532,6 +4549,7 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eSetDescriptorBufferOffsetsInfoEXT: return "SetDescriptorBufferOffsetsInfoEXT"; case StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT: return "BindDescriptorBufferEmbeddedSamplersInfoEXT"; case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV: return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV"; + case StructureType::ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV: return "PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -5151,9 +5169,13 @@ namespace VULKAN_HPP_NAMESPACE } } - VULKAN_HPP_INLINE std::string to_string( MemoryMapFlagBits ) + VULKAN_HPP_INLINE std::string to_string( MemoryMapFlagBits value ) { - return "(void)"; + switch ( value ) + { + case MemoryMapFlagBits::ePlacedEXT: return "PlacedEXT"; + default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; + } } VULKAN_HPP_INLINE std::string to_string( ImageAspectFlagBits value ) @@ -8111,9 +8133,13 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_map_memory2 === - VULKAN_HPP_INLINE std::string to_string( MemoryUnmapFlagBitsKHR ) + VULKAN_HPP_INLINE std::string to_string( MemoryUnmapFlagBitsKHR value ) { - return "(void)"; + switch ( value ) + { + case MemoryUnmapFlagBitsKHR::eReserveEXT: return "ReserveEXT"; + default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; + } } //=== VK_EXT_surface_maintenance1 === diff --git a/third_party/vulkan/vulkan_video.hpp b/third_party/vulkan/vulkan_video.hpp index 570dfa4..fb82aa3 100644 --- a/third_party/vulkan/vulkan_video.hpp +++ b/third_party/vulkan/vulkan_video.hpp @@ -1,4 +1,4 @@ -// Copyright 2021-2023 The Khronos Group Inc. +// Copyright 2021-2024 The Khronos Group Inc. // SPDX-License-Identifier: Apache-2.0 OR MIT // @@ -7,6 +7,8 @@ #ifndef VULKAN_VIDEO_HPP #define VULKAN_VIDEO_HPP +#include +#include #include #include #include @@ -266,6 +268,164 @@ namespace VULKAN_HPP_NAMESPACE eInvalid = STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID }; + //=== vulkan_video_codec_av1std === + + enum class AV1Profile + { + eMain = STD_VIDEO_AV1_PROFILE_MAIN, + eHigh = STD_VIDEO_AV1_PROFILE_HIGH, + eProfessional = STD_VIDEO_AV1_PROFILE_PROFESSIONAL, + eInvalid = STD_VIDEO_AV1_PROFILE_INVALID + }; + + enum class AV1Level + { + e2_0 = STD_VIDEO_AV1_LEVEL_2_0, + e2_1 = STD_VIDEO_AV1_LEVEL_2_1, + e2_2 = STD_VIDEO_AV1_LEVEL_2_2, + e2_3 = STD_VIDEO_AV1_LEVEL_2_3, + e3_0 = STD_VIDEO_AV1_LEVEL_3_0, + e3_1 = STD_VIDEO_AV1_LEVEL_3_1, + e3_2 = STD_VIDEO_AV1_LEVEL_3_2, + e3_3 = STD_VIDEO_AV1_LEVEL_3_3, + e4_0 = STD_VIDEO_AV1_LEVEL_4_0, + e4_1 = STD_VIDEO_AV1_LEVEL_4_1, + e4_2 = STD_VIDEO_AV1_LEVEL_4_2, + e4_3 = STD_VIDEO_AV1_LEVEL_4_3, + e5_0 = STD_VIDEO_AV1_LEVEL_5_0, + e5_1 = STD_VIDEO_AV1_LEVEL_5_1, + e5_2 = STD_VIDEO_AV1_LEVEL_5_2, + e5_3 = STD_VIDEO_AV1_LEVEL_5_3, + e6_0 = STD_VIDEO_AV1_LEVEL_6_0, + e6_1 = STD_VIDEO_AV1_LEVEL_6_1, + e6_2 = STD_VIDEO_AV1_LEVEL_6_2, + e6_3 = STD_VIDEO_AV1_LEVEL_6_3, + e7_0 = STD_VIDEO_AV1_LEVEL_7_0, + e7_1 = STD_VIDEO_AV1_LEVEL_7_1, + e7_2 = STD_VIDEO_AV1_LEVEL_7_2, + e7_3 = STD_VIDEO_AV1_LEVEL_7_3, + eInvalid = STD_VIDEO_AV1_LEVEL_INVALID + }; + + enum class AV1FrameType + { + eKey = STD_VIDEO_AV1_FRAME_TYPE_KEY, + eInter = STD_VIDEO_AV1_FRAME_TYPE_INTER, + eIntraOnly = STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY, + eSwitch = STD_VIDEO_AV1_FRAME_TYPE_SWITCH, + eInvalid = STD_VIDEO_AV1_FRAME_TYPE_INVALID + }; + + enum class AV1ReferenceName + { + eIntraFrame = STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME, + eLastFrame = STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME, + eLast2Frame = STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME, + eLast3Frame = STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME, + eGoldenFrame = STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME, + eBwdrefFrame = STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME, + eAltref2Frame = STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME, + eAltrefFrame = STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME, + eInvalid = STD_VIDEO_AV1_REFERENCE_NAME_INVALID + }; + + enum class AV1InterpolationFilter + { + eEighttap = STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP, + eEighttapSmooth = STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH, + eEighttapSharp = STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP, + eBilinear = STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR, + eSwitchable = STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE, + eInvalid = STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID + }; + + enum class AV1TxMode + { + eOnly4X4 = STD_VIDEO_AV1_TX_MODE_ONLY_4X4, + eLargest = STD_VIDEO_AV1_TX_MODE_LARGEST, + eSelect = STD_VIDEO_AV1_TX_MODE_SELECT, + eInvalid = STD_VIDEO_AV1_TX_MODE_INVALID + }; + + enum class AV1FrameRestorationType + { + eNone = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE, + eWiener = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER, + eSgrproj = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ, + eSwitchable = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE, + eInvalid = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID + }; + + enum class AV1ColorPrimaries + { + eBt709 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709, + eBtUnspecified = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED, + eBt470M = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M, + eBt470BG = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G, + eBt601 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601, + eSmpte240 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240, + eGenericFilm = STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM, + eBt2020 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020, + eXyz = STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ, + eSmpte431 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431, + eSmpte432 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432, + eEbu3213 = STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213, + eInvalid = STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID + }; + + enum class AV1TransferCharacteristics + { + eReserved0 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0, + eBt709 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709, + eUnspecified = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED, + eReserved3 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3, + eBt470M = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M, + eBt470BG = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G, + eBt601 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601, + eSmpte240 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240, + eLinear = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR, + eLog100 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100, + eLog100Sqrt10 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10, + eIec61966 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966, + eBt1361 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361, + eSrgb = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB, + eBt2020_10Bit = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT, + eBt2020_12Bit = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT, + eSmpte2084 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084, + eSmpte428 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428, + eHlg = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG, + eInvalid = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID + }; + + enum class AV1MatrixCoefficients + { + eIdentity = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY, + eBt709 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709, + eUnspecified = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED, + eReserved3 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3, + eFcc = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC, + eBt470BG = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G, + eBt601 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601, + eSmpte240 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240, + eSmpteYcgco = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO, + eBt2020Ncl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL, + eBt2020Cl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL, + eSmpte2085 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085, + eChromatNcl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL, + eChromatCl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL, + eIctcp = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP, + eInvalid = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID + }; + + enum class AV1ChromaSamplePosition + { + eUnknown = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN, + eVertical = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL, + eColocated = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED, + eReserved = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED, + eInvalid = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID + }; + //=============== //=== STRUCTS === //=============== @@ -2697,6 +2857,860 @@ namespace VULKAN_HPP_NAMESPACE uint8_t TemporalId = {}; }; + //=== vulkan_video_codec_av1std === + + struct AV1ColorConfigFlags + { + using NativeType = StdVideoAV1ColorConfigFlags; + + operator StdVideoAV1ColorConfigFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1ColorConfigFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AV1ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( mono_chrome == rhs.mono_chrome ) && ( color_range == rhs.color_range ) && ( separate_uv_delta_q == rhs.separate_uv_delta_q ) && + ( color_description_present_flag == rhs.color_description_present_flag ) && ( reserved == rhs.reserved ); + } + + bool operator!=( AV1ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t mono_chrome : 1; + uint32_t color_range : 1; + uint32_t separate_uv_delta_q : 1; + uint32_t color_description_present_flag : 1; + uint32_t reserved : 28; + }; + + struct AV1ColorConfig + { + using NativeType = StdVideoAV1ColorConfig; + + operator StdVideoAV1ColorConfig const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1ColorConfig &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AV1ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( BitDepth == rhs.BitDepth ) && ( subsampling_x == rhs.subsampling_x ) && ( subsampling_y == rhs.subsampling_y ) && + ( reserved1 == rhs.reserved1 ) && ( color_primaries == rhs.color_primaries ) && ( transfer_characteristics == rhs.transfer_characteristics ) && + ( matrix_coefficients == rhs.matrix_coefficients ) && ( chroma_sample_position == rhs.chroma_sample_position ); + } + + bool operator!=( AV1ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags flags = {}; + uint8_t BitDepth = {}; + uint8_t subsampling_x = {}; + uint8_t subsampling_y = {}; + uint8_t reserved1 = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries color_primaries = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries::eBt709; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics transfer_characteristics = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics::eReserved0; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients matrix_coefficients = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients::eIdentity; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition chroma_sample_position = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition::eUnknown; + }; + + struct AV1TimingInfoFlags + { + using NativeType = StdVideoAV1TimingInfoFlags; + + operator StdVideoAV1TimingInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1TimingInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AV1TimingInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( equal_picture_interval == rhs.equal_picture_interval ) && ( reserved == rhs.reserved ); + } + + bool operator!=( AV1TimingInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t equal_picture_interval : 1; + uint32_t reserved : 31; + }; + + struct AV1TimingInfo + { + using NativeType = StdVideoAV1TimingInfo; + + operator StdVideoAV1TimingInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1TimingInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AV1TimingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( num_units_in_display_tick == rhs.num_units_in_display_tick ) && ( time_scale == rhs.time_scale ) && + ( num_ticks_per_picture_minus_1 == rhs.num_ticks_per_picture_minus_1 ); + } + + bool operator!=( AV1TimingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags flags = {}; + uint32_t num_units_in_display_tick = {}; + uint32_t time_scale = {}; + uint32_t num_ticks_per_picture_minus_1 = {}; + }; + + struct AV1LoopFilterFlags + { + using NativeType = StdVideoAV1LoopFilterFlags; + + operator StdVideoAV1LoopFilterFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1LoopFilterFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AV1LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( loop_filter_delta_enabled == rhs.loop_filter_delta_enabled ) && ( loop_filter_delta_update == rhs.loop_filter_delta_update ) && + ( reserved == rhs.reserved ); + } + + bool operator!=( AV1LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t loop_filter_delta_enabled : 1; + uint32_t loop_filter_delta_update : 1; + uint32_t reserved : 30; + }; + + struct AV1LoopFilter + { + using NativeType = StdVideoAV1LoopFilter; + + operator StdVideoAV1LoopFilter const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1LoopFilter &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AV1LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( loop_filter_level == rhs.loop_filter_level ) && ( loop_filter_sharpness == rhs.loop_filter_sharpness ) && + ( update_ref_delta == rhs.update_ref_delta ) && ( loop_filter_ref_deltas == rhs.loop_filter_ref_deltas ) && + ( update_mode_delta == rhs.update_mode_delta ) && ( loop_filter_mode_deltas == rhs.loop_filter_mode_deltas ); + } + + bool operator!=( AV1LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags flags = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D loop_filter_level = {}; + uint8_t loop_filter_sharpness = {}; + uint8_t update_ref_delta = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D loop_filter_ref_deltas = {}; + uint8_t update_mode_delta = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D loop_filter_mode_deltas = {}; + }; + + struct AV1QuantizationFlags + { + using NativeType = StdVideoAV1QuantizationFlags; + + operator StdVideoAV1QuantizationFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1QuantizationFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AV1QuantizationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( using_qmatrix == rhs.using_qmatrix ) && ( diff_uv_delta == rhs.diff_uv_delta ) && ( reserved == rhs.reserved ); + } + + bool operator!=( AV1QuantizationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t using_qmatrix : 1; + uint32_t diff_uv_delta : 1; + uint32_t reserved : 30; + }; + + struct AV1Quantization + { + using NativeType = StdVideoAV1Quantization; + + operator StdVideoAV1Quantization const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1Quantization &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AV1Quantization const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( base_q_idx == rhs.base_q_idx ) && ( DeltaQYDc == rhs.DeltaQYDc ) && ( DeltaQUDc == rhs.DeltaQUDc ) && + ( DeltaQUAc == rhs.DeltaQUAc ) && ( DeltaQVDc == rhs.DeltaQVDc ) && ( DeltaQVAc == rhs.DeltaQVAc ) && ( qm_y == rhs.qm_y ) && + ( qm_u == rhs.qm_u ) && ( qm_v == rhs.qm_v ); + } + + bool operator!=( AV1Quantization const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags flags = {}; + uint8_t base_q_idx = {}; + int8_t DeltaQYDc = {}; + int8_t DeltaQUDc = {}; + int8_t DeltaQUAc = {}; + int8_t DeltaQVDc = {}; + int8_t DeltaQVAc = {}; + uint8_t qm_y = {}; + uint8_t qm_u = {}; + uint8_t qm_v = {}; + }; + + struct AV1Segmentation + { + using NativeType = StdVideoAV1Segmentation; + + operator StdVideoAV1Segmentation const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1Segmentation &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AV1Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( FeatureEnabled == rhs.FeatureEnabled ) && ( FeatureData == rhs.FeatureData ); + } + + bool operator!=( AV1Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::ArrayWrapper1D FeatureEnabled = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper2D FeatureData = {}; + }; + + struct AV1TileInfoFlags + { + using NativeType = StdVideoAV1TileInfoFlags; + + operator StdVideoAV1TileInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1TileInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AV1TileInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( uniform_tile_spacing_flag == rhs.uniform_tile_spacing_flag ) && ( reserved == rhs.reserved ); + } + + bool operator!=( AV1TileInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t uniform_tile_spacing_flag : 1; + uint32_t reserved : 31; + }; + + struct AV1TileInfo + { + using NativeType = StdVideoAV1TileInfo; + + operator StdVideoAV1TileInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1TileInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AV1TileInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( TileCols == rhs.TileCols ) && ( TileRows == rhs.TileRows ) && + ( context_update_tile_id == rhs.context_update_tile_id ) && ( tile_size_bytes_minus_1 == rhs.tile_size_bytes_minus_1 ) && + ( reserved1 == rhs.reserved1 ) && ( pMiColStarts == rhs.pMiColStarts ) && ( pMiRowStarts == rhs.pMiRowStarts ) && + ( pWidthInSbsMinus1 == rhs.pWidthInSbsMinus1 ) && ( pHeightInSbsMinus1 == rhs.pHeightInSbsMinus1 ); + } + + bool operator!=( AV1TileInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags flags = {}; + uint8_t TileCols = {}; + uint8_t TileRows = {}; + uint16_t context_update_tile_id = {}; + uint8_t tile_size_bytes_minus_1 = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D reserved1 = {}; + const uint16_t * pMiColStarts = {}; + const uint16_t * pMiRowStarts = {}; + const uint16_t * pWidthInSbsMinus1 = {}; + const uint16_t * pHeightInSbsMinus1 = {}; + }; + + struct AV1CDEF + { + using NativeType = StdVideoAV1CDEF; + + operator StdVideoAV1CDEF const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1CDEF &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AV1CDEF const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( cdef_damping_minus_3 == rhs.cdef_damping_minus_3 ) && ( cdef_bits == rhs.cdef_bits ) && ( cdef_y_pri_strength == rhs.cdef_y_pri_strength ) && + ( cdef_y_sec_strength == rhs.cdef_y_sec_strength ) && ( cdef_uv_pri_strength == rhs.cdef_uv_pri_strength ) && + ( cdef_uv_sec_strength == rhs.cdef_uv_sec_strength ); + } + + bool operator!=( AV1CDEF const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint8_t cdef_damping_minus_3 = {}; + uint8_t cdef_bits = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D cdef_y_pri_strength = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D cdef_y_sec_strength = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D cdef_uv_pri_strength = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D cdef_uv_sec_strength = {}; + }; + + struct AV1LoopRestoration + { + using NativeType = StdVideoAV1LoopRestoration; + + operator StdVideoAV1LoopRestoration const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1LoopRestoration &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AV1LoopRestoration const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( FrameRestorationType == rhs.FrameRestorationType ) && ( LoopRestorationSize == rhs.LoopRestorationSize ); + } + + bool operator!=( AV1LoopRestoration const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::ArrayWrapper1D FrameRestorationType = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D LoopRestorationSize = {}; + }; + + struct AV1GlobalMotion + { + using NativeType = StdVideoAV1GlobalMotion; + + operator StdVideoAV1GlobalMotion const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1GlobalMotion &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AV1GlobalMotion const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( GmType == rhs.GmType ) && ( gm_params == rhs.gm_params ); + } + + bool operator!=( AV1GlobalMotion const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::ArrayWrapper1D GmType = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper2D gm_params = {}; + }; + + struct AV1FilmGrainFlags + { + using NativeType = StdVideoAV1FilmGrainFlags; + + operator StdVideoAV1FilmGrainFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1FilmGrainFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AV1FilmGrainFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( chroma_scaling_from_luma == rhs.chroma_scaling_from_luma ) && ( overlap_flag == rhs.overlap_flag ) && + ( clip_to_restricted_range == rhs.clip_to_restricted_range ) && ( update_grain == rhs.update_grain ) && ( reserved == rhs.reserved ); + } + + bool operator!=( AV1FilmGrainFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t chroma_scaling_from_luma : 1; + uint32_t overlap_flag : 1; + uint32_t clip_to_restricted_range : 1; + uint32_t update_grain : 1; + uint32_t reserved : 28; + }; + + struct AV1FilmGrain + { + using NativeType = StdVideoAV1FilmGrain; + + operator StdVideoAV1FilmGrain const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1FilmGrain &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AV1FilmGrain const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( grain_scaling_minus_8 == rhs.grain_scaling_minus_8 ) && ( ar_coeff_lag == rhs.ar_coeff_lag ) && + ( ar_coeff_shift_minus_6 == rhs.ar_coeff_shift_minus_6 ) && ( grain_scale_shift == rhs.grain_scale_shift ) && ( grain_seed == rhs.grain_seed ) && + ( film_grain_params_ref_idx == rhs.film_grain_params_ref_idx ) && ( num_y_points == rhs.num_y_points ) && + ( point_y_value == rhs.point_y_value ) && ( point_y_scaling == rhs.point_y_scaling ) && ( num_cb_points == rhs.num_cb_points ) && + ( point_cb_value == rhs.point_cb_value ) && ( point_cb_scaling == rhs.point_cb_scaling ) && ( num_cr_points == rhs.num_cr_points ) && + ( point_cr_value == rhs.point_cr_value ) && ( point_cr_scaling == rhs.point_cr_scaling ) && + ( ar_coeffs_y_plus_128 == rhs.ar_coeffs_y_plus_128 ) && ( ar_coeffs_cb_plus_128 == rhs.ar_coeffs_cb_plus_128 ) && + ( ar_coeffs_cr_plus_128 == rhs.ar_coeffs_cr_plus_128 ) && ( cb_mult == rhs.cb_mult ) && ( cb_luma_mult == rhs.cb_luma_mult ) && + ( cb_offset == rhs.cb_offset ) && ( cr_mult == rhs.cr_mult ) && ( cr_luma_mult == rhs.cr_luma_mult ) && ( cr_offset == rhs.cr_offset ); + } + + bool operator!=( AV1FilmGrain const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags flags = {}; + uint8_t grain_scaling_minus_8 = {}; + uint8_t ar_coeff_lag = {}; + uint8_t ar_coeff_shift_minus_6 = {}; + uint8_t grain_scale_shift = {}; + uint16_t grain_seed = {}; + uint8_t film_grain_params_ref_idx = {}; + uint8_t num_y_points = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D point_y_value = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D point_y_scaling = {}; + uint8_t num_cb_points = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D point_cb_value = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D point_cb_scaling = {}; + uint8_t num_cr_points = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D point_cr_value = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D point_cr_scaling = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D ar_coeffs_y_plus_128 = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D ar_coeffs_cb_plus_128 = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D ar_coeffs_cr_plus_128 = {}; + uint8_t cb_mult = {}; + uint8_t cb_luma_mult = {}; + uint16_t cb_offset = {}; + uint8_t cr_mult = {}; + uint8_t cr_luma_mult = {}; + uint16_t cr_offset = {}; + }; + + struct AV1SequenceHeaderFlags + { + using NativeType = StdVideoAV1SequenceHeaderFlags; + + operator StdVideoAV1SequenceHeaderFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1SequenceHeaderFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AV1SequenceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( still_picture == rhs.still_picture ) && ( reduced_still_picture_header == rhs.reduced_still_picture_header ) && + ( use_128x128_superblock == rhs.use_128x128_superblock ) && ( enable_filter_intra == rhs.enable_filter_intra ) && + ( enable_intra_edge_filter == rhs.enable_intra_edge_filter ) && ( enable_interintra_compound == rhs.enable_interintra_compound ) && + ( enable_masked_compound == rhs.enable_masked_compound ) && ( enable_warped_motion == rhs.enable_warped_motion ) && + ( enable_dual_filter == rhs.enable_dual_filter ) && ( enable_order_hint == rhs.enable_order_hint ) && + ( enable_jnt_comp == rhs.enable_jnt_comp ) && ( enable_ref_frame_mvs == rhs.enable_ref_frame_mvs ) && + ( frame_id_numbers_present_flag == rhs.frame_id_numbers_present_flag ) && ( enable_superres == rhs.enable_superres ) && + ( enable_cdef == rhs.enable_cdef ) && ( enable_restoration == rhs.enable_restoration ) && + ( film_grain_params_present == rhs.film_grain_params_present ) && ( timing_info_present_flag == rhs.timing_info_present_flag ) && + ( initial_display_delay_present_flag == rhs.initial_display_delay_present_flag ) && ( reserved == rhs.reserved ); + } + + bool operator!=( AV1SequenceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t still_picture : 1; + uint32_t reduced_still_picture_header : 1; + uint32_t use_128x128_superblock : 1; + uint32_t enable_filter_intra : 1; + uint32_t enable_intra_edge_filter : 1; + uint32_t enable_interintra_compound : 1; + uint32_t enable_masked_compound : 1; + uint32_t enable_warped_motion : 1; + uint32_t enable_dual_filter : 1; + uint32_t enable_order_hint : 1; + uint32_t enable_jnt_comp : 1; + uint32_t enable_ref_frame_mvs : 1; + uint32_t frame_id_numbers_present_flag : 1; + uint32_t enable_superres : 1; + uint32_t enable_cdef : 1; + uint32_t enable_restoration : 1; + uint32_t film_grain_params_present : 1; + uint32_t timing_info_present_flag : 1; + uint32_t initial_display_delay_present_flag : 1; + uint32_t reserved : 13; + }; + + struct AV1SequenceHeader + { + using NativeType = StdVideoAV1SequenceHeader; + + operator StdVideoAV1SequenceHeader const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1SequenceHeader &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AV1SequenceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( seq_profile == rhs.seq_profile ) && ( frame_width_bits_minus_1 == rhs.frame_width_bits_minus_1 ) && + ( frame_height_bits_minus_1 == rhs.frame_height_bits_minus_1 ) && ( max_frame_width_minus_1 == rhs.max_frame_width_minus_1 ) && + ( max_frame_height_minus_1 == rhs.max_frame_height_minus_1 ) && ( delta_frame_id_length_minus_2 == rhs.delta_frame_id_length_minus_2 ) && + ( additional_frame_id_length_minus_1 == rhs.additional_frame_id_length_minus_1 ) && ( order_hint_bits_minus_1 == rhs.order_hint_bits_minus_1 ) && + ( seq_force_integer_mv == rhs.seq_force_integer_mv ) && ( seq_force_screen_content_tools == rhs.seq_force_screen_content_tools ) && + ( reserved1 == rhs.reserved1 ) && ( pColorConfig == rhs.pColorConfig ) && ( pTimingInfo == rhs.pTimingInfo ); + } + + bool operator!=( AV1SequenceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags flags = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile seq_profile = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile::eMain; + uint8_t frame_width_bits_minus_1 = {}; + uint8_t frame_height_bits_minus_1 = {}; + uint16_t max_frame_width_minus_1 = {}; + uint16_t max_frame_height_minus_1 = {}; + uint8_t delta_frame_id_length_minus_2 = {}; + uint8_t additional_frame_id_length_minus_1 = {}; + uint8_t order_hint_bits_minus_1 = {}; + uint8_t seq_force_integer_mv = {}; + uint8_t seq_force_screen_content_tools = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D reserved1 = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig * pColorConfig = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo * pTimingInfo = {}; + }; + + //=== vulkan_video_codec_av1std_decode === + + struct DecodeAV1PictureInfoFlags + { + using NativeType = StdVideoDecodeAV1PictureInfoFlags; + + operator StdVideoDecodeAV1PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeAV1PictureInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( DecodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( error_resilient_mode == rhs.error_resilient_mode ) && ( disable_cdf_update == rhs.disable_cdf_update ) && + ( use_superres == rhs.use_superres ) && ( render_and_frame_size_different == rhs.render_and_frame_size_different ) && + ( allow_screen_content_tools == rhs.allow_screen_content_tools ) && ( is_filter_switchable == rhs.is_filter_switchable ) && + ( force_integer_mv == rhs.force_integer_mv ) && ( frame_size_override_flag == rhs.frame_size_override_flag ) && + ( buffer_removal_time_present_flag == rhs.buffer_removal_time_present_flag ) && ( allow_intrabc == rhs.allow_intrabc ) && + ( frame_refs_short_signaling == rhs.frame_refs_short_signaling ) && ( allow_high_precision_mv == rhs.allow_high_precision_mv ) && + ( is_motion_mode_switchable == rhs.is_motion_mode_switchable ) && ( use_ref_frame_mvs == rhs.use_ref_frame_mvs ) && + ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( allow_warped_motion == rhs.allow_warped_motion ) && + ( reduced_tx_set == rhs.reduced_tx_set ) && ( reference_select == rhs.reference_select ) && ( skip_mode_present == rhs.skip_mode_present ) && + ( delta_q_present == rhs.delta_q_present ) && ( delta_lf_present == rhs.delta_lf_present ) && ( delta_lf_multi == rhs.delta_lf_multi ) && + ( segmentation_enabled == rhs.segmentation_enabled ) && ( segmentation_update_map == rhs.segmentation_update_map ) && + ( segmentation_temporal_update == rhs.segmentation_temporal_update ) && ( segmentation_update_data == rhs.segmentation_update_data ) && + ( UsesLr == rhs.UsesLr ) && ( usesChromaLr == rhs.usesChromaLr ) && ( apply_grain == rhs.apply_grain ) && ( reserved == rhs.reserved ); + } + + bool operator!=( DecodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + 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 reference_select : 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 apply_grain : 1; + uint32_t reserved : 3; + }; + + struct DecodeAV1PictureInfo + { + using NativeType = StdVideoDecodeAV1PictureInfo; + + operator StdVideoDecodeAV1PictureInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeAV1PictureInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( DecodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( current_frame_id == rhs.current_frame_id ) && ( OrderHint == rhs.OrderHint ) && + ( primary_ref_frame == rhs.primary_ref_frame ) && ( refresh_frame_flags == rhs.refresh_frame_flags ) && ( reserved1 == rhs.reserved1 ) && + ( interpolation_filter == rhs.interpolation_filter ) && ( TxMode == rhs.TxMode ) && ( delta_q_res == rhs.delta_q_res ) && + ( delta_lf_res == rhs.delta_lf_res ) && ( SkipModeFrame == rhs.SkipModeFrame ) && ( coded_denom == rhs.coded_denom ) && + ( reserved2 == rhs.reserved2 ) && ( OrderHints == rhs.OrderHints ) && ( expectedFrameId == rhs.expectedFrameId ) && + ( pTileInfo == rhs.pTileInfo ) && ( pQuantization == rhs.pQuantization ) && ( pSegmentation == rhs.pSegmentation ) && + ( pLoopFilter == rhs.pLoopFilter ) && ( pCDEF == rhs.pCDEF ) && ( pLoopRestoration == rhs.pLoopRestoration ) && + ( pGlobalMotion == rhs.pGlobalMotion ) && ( pFilmGrain == rhs.pFilmGrain ); + } + + bool operator!=( DecodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags flags = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey; + uint32_t current_frame_id = {}; + uint8_t OrderHint = {}; + uint8_t primary_ref_frame = {}; + uint8_t refresh_frame_flags = {}; + uint8_t reserved1 = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter interpolation_filter = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter::eEighttap; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode TxMode = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode::eOnly4X4; + uint8_t delta_q_res = {}; + uint8_t delta_lf_res = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D SkipModeFrame = {}; + uint8_t coded_denom = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D reserved2 = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D OrderHints = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D expectedFrameId = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo * pTileInfo = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization * pQuantization = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation * pSegmentation = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter * pLoopFilter = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF * pCDEF = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration * pLoopRestoration = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion * pGlobalMotion = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain * pFilmGrain = {}; + }; + + struct DecodeAV1ReferenceInfoFlags + { + using NativeType = StdVideoDecodeAV1ReferenceInfoFlags; + + operator StdVideoDecodeAV1ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeAV1ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( DecodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( segmentation_enabled == rhs.segmentation_enabled ) && + ( reserved == rhs.reserved ); + } + + bool operator!=( DecodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t disable_frame_end_update_cdf : 1; + uint32_t segmentation_enabled : 1; + uint32_t reserved : 30; + }; + + struct DecodeAV1ReferenceInfo + { + using NativeType = StdVideoDecodeAV1ReferenceInfo; + + operator StdVideoDecodeAV1ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeAV1ReferenceInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( DecodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( RefFrameSignBias == rhs.RefFrameSignBias ) && ( OrderHint == rhs.OrderHint ) && + ( SavedOrderHints == rhs.SavedOrderHints ); + } + + bool operator!=( DecodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags flags = {}; + uint8_t frame_type = {}; + uint8_t RefFrameSignBias = {}; + uint8_t OrderHint = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D SavedOrderHints = {}; + }; + } // namespace VULKAN_HPP_VIDEO_NAMESPACE } // namespace VULKAN_HPP_NAMESPACE #endif From 784156c3959e9f9638a159e62bca45a0c5b1608b Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Sat, 24 Feb 2024 03:57:59 +0100 Subject: [PATCH 3/6] fixing weird color bug with mlx_get_image_pixel --- example/main.c | 2 +- src/core/bridge.cpp | 10 ++++++++-- src/platform/inputs.cpp | 8 ++++---- src/renderer/images/texture.cpp | 8 ++++++-- 4 files changed, 19 insertions(+), 9 deletions(-) diff --git a/example/main.c b/example/main.c index b5c94cf..acb2906 100644 --- a/example/main.c +++ b/example/main.c @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/04 17:55:21 by maldavid #+# #+# */ -/* Updated: 2024/01/26 11:59:34 by maldavid ### ########.fr */ +/* Updated: 2024/02/24 01:07:56 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/src/core/bridge.cpp b/src/core/bridge.cpp index 3580fcd..f980141 100644 --- a/src/core/bridge.cpp +++ b/src/core/bridge.cpp @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/04 17:35:20 by maldavid #+# #+# */ -/* Updated: 2024/01/19 05:35:38 by maldavid ### ########.fr */ +/* Updated: 2024/02/23 22:37:24 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ @@ -120,7 +120,13 @@ extern "C" int mlx_get_image_pixel(void* mlx, void* img, int x, int y) { MLX_CHECK_APPLICATION_POINTER(mlx); - return static_cast(mlx)->getTexturePixel(img, x, y); + int color = static_cast(mlx)->getTexturePixel(img, x, y); + unsigned char color_bits[4]; + color_bits[0] = (color & 0x000000FF); + color_bits[1] = (color & 0x0000FF00) >> 8; + color_bits[2] = (color & 0x00FF0000) >> 16; + color_bits[3] = (color & 0xFF000000) >> 24; + return *reinterpret_cast(color_bits); } void mlx_set_image_pixel(void* mlx, void* img, int x, int y, int color) diff --git a/src/platform/inputs.cpp b/src/platform/inputs.cpp index 738fa1b..cc826f9 100644 --- a/src/platform/inputs.cpp +++ b/src/platform/inputs.cpp @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/05 16:30:19 by maldavid #+# #+# */ -/* Updated: 2024/01/16 07:59:15 by maldavid ### ########.fr */ +/* Updated: 2024/02/23 22:27:30 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ @@ -123,19 +123,19 @@ namespace mlx case SDL_WINDOWEVENT_FOCUS_GAINED: { if(win_hook.hook) - win_hook.hook(4, win_hook.param); + win_hook.hook(5, win_hook.param); break; } case SDL_WINDOWEVENT_LEAVE: { if(win_hook.hook) - win_hook.hook(5, win_hook.param); + win_hook.hook(6, win_hook.param); break; } case SDL_WINDOWEVENT_FOCUS_LOST: { if(win_hook.hook) - win_hook.hook(4, win_hook.param); + win_hook.hook(7, win_hook.param); break; } diff --git a/src/renderer/images/texture.cpp b/src/renderer/images/texture.cpp index 16d693f..1fe116f 100644 --- a/src/renderer/images/texture.cpp +++ b/src/renderer/images/texture.cpp @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/03/31 18:03:35 by maldavid #+# #+# */ -/* Updated: 2024/01/18 10:18:22 by maldavid ### ########.fr */ +/* Updated: 2024/02/24 03:51:59 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ @@ -98,7 +98,11 @@ namespace mlx if(_map == nullptr) openCPUmap(); uint32_t color = _cpu_map[(y * getWidth()) + x]; - return (color); + uint8_t* bytes = reinterpret_cast(&color); + uint8_t tmp = bytes[0]; + bytes[0] = bytes[2]; + bytes[2] = tmp; + return *reinterpret_cast(bytes); } void Texture::openCPUmap() From 828024e1311e9b5a40556f67214783d3db6cbad9 Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Sat, 24 Feb 2024 04:47:05 +0100 Subject: [PATCH 4/6] removing unecessary SDL window creation in Vulkan Instance creation --- src/renderer/core/vk_instance.cpp | 37 +++++++++++++++++++------------ 1 file changed, 23 insertions(+), 14 deletions(-) diff --git a/src/renderer/core/vk_instance.cpp b/src/renderer/core/vk_instance.cpp index bd9582b..013e387 100644 --- a/src/renderer/core/vk_instance.cpp +++ b/src/renderer/core/vk_instance.cpp @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/08 19:04:21 by maldavid #+# #+# */ -/* Updated: 2024/01/10 21:54:06 by maldavid ### ########.fr */ +/* Updated: 2024/02/24 04:31:00 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ @@ -58,25 +58,34 @@ namespace mlx std::vector Instance::getRequiredExtensions() { - unsigned int count = 0; - SDL_Window* window = SDL_CreateWindow("", 0, 0, 1, 1, SDL_WINDOW_VULKAN | SDL_WINDOW_HIDDEN); - if(!window) - core::error::report(e_kind::fatal_error, "Vulkan : cannot get instance extentions from window : %s", SDL_GetError()); + std::vector extensions; + extensions.push_back(VK_KHR_SURFACE_EXTENSION_NAME); + + #ifdef VK_USE_PLATFORM_XCB_KHR + extensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME); + #endif - if(!SDL_Vulkan_GetInstanceExtensions(window, &count, nullptr)) - core::error::report(e_kind::fatal_error, "Vulkan : cannot get instance extentions from window : %s", SDL_GetError()); + #ifdef VK_USE_PLATFORM_XLIB_KHR + extensions.push_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME); + #endif - std::vector extensions = { VK_EXT_DEBUG_REPORT_EXTENSION_NAME }; - size_t additional_extension_count = extensions.size(); - extensions.resize(additional_extension_count + count); + #ifdef VK_USE_PLATFORM_WAYLAND_KHR + extensions.push_back(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME); + #endif - if(!SDL_Vulkan_GetInstanceExtensions(window, &count, extensions.data() + additional_extension_count)) - core::error::report(e_kind::error, "Vulkan : cannot get instance extentions from window : %s", SDL_GetError()); + #ifdef VK_USE_PLATFORM_WIN32_KHR + extensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME); + #endif + + #ifdef VK_USE_PLATFORM_METAL_EXT + extensions.push_back(VK_EXT_METAL_SURFACE_EXTENSION_NAME); + #endif if constexpr(enableValidationLayers) + { + extensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME); extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME); - - SDL_DestroyWindow(window); + } return extensions; } From 3624caf5198c3a3ccb8f5fb4f7cdac8d598024c5 Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Sun, 25 Feb 2024 08:04:44 +0100 Subject: [PATCH 5/6] adding std namespace to all libstd provided primitive types --- src/core/UUID.cpp | 4 +-- src/core/UUID.h | 6 ++-- src/core/application.cpp | 4 +-- src/core/application.h | 8 +++--- src/core/application.inl | 8 +++--- src/core/bridge.cpp | 2 +- src/core/fps.cpp | 6 ++-- src/core/fps.h | 12 ++++---- src/core/graphics.cpp | 2 +- src/core/graphics.h | 4 +-- src/core/graphics.inl | 4 +-- src/platform/inputs.cpp | 2 +- src/platform/inputs.h | 10 +++---- src/platform/window.cpp | 16 +++++------ src/platform/window.h | 4 +-- src/renderer/buffers/vk_ibo.h | 2 +- src/renderer/buffers/vk_ubo.cpp | 10 +++---- src/renderer/buffers/vk_ubo.h | 6 ++-- src/renderer/buffers/vk_vbo.cpp | 6 ++-- src/renderer/buffers/vk_vbo.h | 10 +++---- .../command/single_time_cmd_manager.h | 2 +- src/renderer/command/vk_cmd_buffer.cpp | 2 +- src/renderer/core/memory.cpp | 6 ++-- src/renderer/core/memory.h | 4 +-- src/renderer/core/render_core.cpp | 4 +-- src/renderer/core/render_core.h | 2 +- src/renderer/core/vk_device.cpp | 14 +++++----- src/renderer/core/vk_fence.cpp | 2 +- src/renderer/core/vk_instance.cpp | 8 +++--- src/renderer/core/vk_queues.cpp | 2 +- src/renderer/core/vk_queues.h | 4 +-- src/renderer/core/vk_validation_layers.cpp | 6 ++-- src/renderer/core/vk_validation_layers.h | 2 +- .../descriptors/vk_descriptor_set.cpp | 2 +- src/renderer/images/texture.cpp | 28 +++++++++---------- src/renderer/images/texture.h | 6 ++-- src/renderer/images/texture_atlas.cpp | 6 ++-- src/renderer/images/texture_atlas.h | 4 +-- src/renderer/images/vk_image.cpp | 12 ++++---- src/renderer/images/vk_image.h | 16 +++++------ src/renderer/pipeline/pipeline.cpp | 12 ++++---- src/renderer/pixel_put.cpp | 10 +++---- src/renderer/pixel_put.h | 10 +++---- src/renderer/renderer.cpp | 2 +- src/renderer/renderer.h | 8 +++--- src/renderer/renderpass/vk_framebuffer.h | 8 +++--- src/renderer/renderpass/vk_render_pass.cpp | 2 +- src/renderer/swapchain/vk_swapchain.cpp | 12 ++++---- src/renderer/swapchain/vk_swapchain.h | 2 +- src/renderer/texts/font.cpp | 10 +++---- src/renderer/texts/font.h | 4 +-- src/renderer/texts/font_library.h | 2 +- src/renderer/texts/text.cpp | 6 ++-- src/renderer/texts/text.h | 4 +-- src/renderer/texts/text_descriptor.cpp | 6 ++-- src/renderer/texts/text_descriptor.h | 6 ++-- src/renderer/texts/text_library.cpp | 4 ++- src/renderer/texts/text_library.h | 2 +- src/renderer/texts/text_manager.cpp | 6 ++-- src/renderer/texts/text_manager.h | 6 ++-- src/utils/icon_mlx.h | 2 +- 61 files changed, 193 insertions(+), 189 deletions(-) diff --git a/src/core/UUID.cpp b/src/core/UUID.cpp index 060f6ba..c7f2bb2 100644 --- a/src/core/UUID.cpp +++ b/src/core/UUID.cpp @@ -18,8 +18,8 @@ namespace mlx { static std::random_device random_device; static std::mt19937_64 engine(random_device()); - static std::uniform_int_distribution uniform_distribution; + static std::uniform_int_distribution uniform_distribution; UUID::UUID() : _uuid(uniform_distribution(engine)) {} - UUID::UUID(uint64_t uuid) : _uuid(uuid) {} + UUID::UUID(std::uint64_t uuid) : _uuid(uuid) {} } diff --git a/src/core/UUID.h b/src/core/UUID.h index aab3dc5..b26df3b 100644 --- a/src/core/UUID.h +++ b/src/core/UUID.h @@ -21,12 +21,12 @@ namespace mlx { public: UUID(); - UUID(uint64_t uuid); + UUID(std::uint64_t uuid); - inline operator uint64_t() const { return _uuid; } + inline operator std::uint64_t() const { return _uuid; } private: - uint64_t _uuid; + std::uint64_t _uuid; }; } diff --git a/src/core/application.cpp b/src/core/application.cpp index eb5ff83..7ae629b 100644 --- a/src/core/application.cpp +++ b/src/core/application.cpp @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/04 22:10:52 by maldavid #+# #+# */ -/* Updated: 2024/01/26 11:56:34 by maldavid ### ########.fr */ +/* Updated: 2024/02/25 07:52:04 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ @@ -40,7 +40,7 @@ namespace mlx::core void Application::run() noexcept { - while(_in->is_running()) + while(_in->isRunning()) { if(!_fps.update()) continue; diff --git a/src/core/application.h b/src/core/application.h index 0f0d00a..48717dc 100644 --- a/src/core/application.h +++ b/src/core/application.h @@ -40,20 +40,20 @@ namespace mlx::core inline void getScreenSize(void* win, int* w, int* h) noexcept; - inline void setFPSCap(uint32_t fps) noexcept; + inline void setFPSCap(std::uint32_t fps) noexcept; inline void* newGraphicsSuport(std::size_t w, std::size_t h, const char* title); inline void clearGraphicsSupport(void* win); inline void destroyGraphicsSupport(void* win); - inline void pixelPut(void* win, int x, int y, uint32_t color) const noexcept; - inline void stringPut(void* win, int x, int y, uint32_t color, char* str); + inline void pixelPut(void* win, int x, int y, std::uint32_t color) const noexcept; + inline void stringPut(void* win, int x, int y, std::uint32_t color, char* str); void* newTexture(int w, int h); void* newStbTexture(char* file, int* w, int* h); // stb textures are format managed by stb image (png, jpg, bpm, ...) inline void texturePut(void* win, void* img, int x, int y); inline int getTexturePixel(void* img, int x, int y); - inline void setTexturePixel(void* img, int x, int y, uint32_t color); + inline void setTexturePixel(void* img, int x, int y, std::uint32_t color); void destroyTexture(void* ptr); inline void loopHook(int (*f)(void*), void* param); diff --git a/src/core/application.inl b/src/core/application.inl index d5ff094..a3ccec1 100644 --- a/src/core/application.inl +++ b/src/core/application.inl @@ -79,7 +79,7 @@ namespace mlx::core *h = DM.h; } - void Application::setFPSCap(uint32_t fps) noexcept + void Application::setFPSCap(std::uint32_t fps) noexcept { _fps.setMaxFPS(fps); } @@ -120,14 +120,14 @@ namespace mlx::core _graphics[*static_cast(win)].reset(); } - void Application::pixelPut(void* win, int x, int y, uint32_t color) const noexcept + void Application::pixelPut(void* win, int x, int y, std::uint32_t color) const noexcept { MLX_PROFILE_FUNCTION(); CHECK_WINDOW_PTR(win); _graphics[*static_cast(win)]->pixelPut(x, y, color); } - void Application::stringPut(void* win, int x, int y, uint32_t color, char* str) + void Application::stringPut(void* win, int x, int y, std::uint32_t color, char* str) { MLX_PROFILE_FUNCTION(); CHECK_WINDOW_PTR(win); @@ -176,7 +176,7 @@ namespace mlx::core return texture->getPixel(x, y); } - void Application::setTexturePixel(void* img, int x, int y, uint32_t color) + void Application::setTexturePixel(void* img, int x, int y, std::uint32_t color) { MLX_PROFILE_FUNCTION(); CHECK_IMAGE_PTR(img, return); diff --git a/src/core/bridge.cpp b/src/core/bridge.cpp index f980141..9fb6b5a 100644 --- a/src/core/bridge.cpp +++ b/src/core/bridge.cpp @@ -300,7 +300,7 @@ extern "C" mlx::core::error::report(e_kind::error, "You cannot set a FPS cap to 0 (nice try)"); return 0; } - static_cast(mlx)->setFPSCap(static_cast(fps)); + static_cast(mlx)->setFPSCap(static_cast(fps)); return 0; } } diff --git a/src/core/fps.cpp b/src/core/fps.cpp index db76414..3c809cb 100644 --- a/src/core/fps.cpp +++ b/src/core/fps.cpp @@ -20,14 +20,14 @@ namespace mlx void FpsManager::init() { _timer = SDL_GetTicks64(); - _fps_before = static_cast(std::chrono::duration_cast(std::chrono::high_resolution_clock::now().time_since_epoch()).count()); - _fps_now = static_cast(std::chrono::duration_cast(std::chrono::high_resolution_clock::now().time_since_epoch()).count()); + _fps_before = static_cast(std::chrono::duration_cast(std::chrono::high_resolution_clock::now().time_since_epoch()).count()); + _fps_now = static_cast(std::chrono::duration_cast(std::chrono::high_resolution_clock::now().time_since_epoch()).count()); } bool FpsManager::update() { using namespace std::chrono_literals; - _fps_now = static_cast(std::chrono::duration_cast(std::chrono::high_resolution_clock::now().time_since_epoch()).count()); + _fps_now = static_cast(std::chrono::duration_cast(std::chrono::high_resolution_clock::now().time_since_epoch()).count()); if(SDL_GetTicks64() - _timer > 1000) _timer += 1000; diff --git a/src/core/fps.h b/src/core/fps.h index 80f25db..4433f07 100644 --- a/src/core/fps.h +++ b/src/core/fps.h @@ -24,17 +24,17 @@ namespace mlx void init(); bool update(); - inline void setMaxFPS(uint32_t fps) noexcept { _max_fps = fps; _ns = 1000000000.0 / fps; } + inline void setMaxFPS(std::uint32_t fps) noexcept { _max_fps = fps; _ns = 1000000000.0 / fps; } ~FpsManager() = default; private: double _ns = 1000000000.0 / 1'337'000.0; - uint64_t _timer = 0; - uint64_t _fps_before = 0; - uint64_t _fps_now = 0; - uint32_t _max_fps = 1'337'000; - uint32_t _fps_elapsed_time = 0; + std::uint64_t _timer = 0; + std::uint64_t _fps_before = 0; + std::uint64_t _fps_now = 0; + std::uint32_t _max_fps = 1'337'000; + std::uint32_t _fps_elapsed_time = 0; }; } diff --git a/src/core/graphics.cpp b/src/core/graphics.cpp index 5092c88..063a363 100644 --- a/src/core/graphics.cpp +++ b/src/core/graphics.cpp @@ -69,7 +69,7 @@ namespace mlx #ifdef GRAPHICS_MEMORY_DUMP // dump memory to file every two seconds - static uint64_t timer = SDL_GetTicks64(); + static std::uint64_t timer = SDL_GetTicks64(); if(SDL_GetTicks64() - timer > 2000) { Render_Core::get().getAllocator().dumpMemoryToJson(); diff --git a/src/core/graphics.h b/src/core/graphics.h index a2c18e7..204b4f3 100644 --- a/src/core/graphics.h +++ b/src/core/graphics.h @@ -45,8 +45,8 @@ namespace mlx void render() noexcept; inline void clearRenderData() noexcept; - inline void pixelPut(int x, int y, uint32_t color) noexcept; - inline void stringPut(int x, int y, uint32_t color, std::string str); + inline void pixelPut(int x, int y, std::uint32_t color) noexcept; + inline void stringPut(int x, int y, std::uint32_t color, std::string str); inline void texturePut(Texture* texture, int x, int y); inline void loadFont(const std::filesystem::path& filepath, float scale); diff --git a/src/core/graphics.inl b/src/core/graphics.inl index b485309..7fd7a94 100644 --- a/src/core/graphics.inl +++ b/src/core/graphics.inl @@ -27,13 +27,13 @@ namespace mlx _texture_manager.clear(); } - void GraphicsSupport::pixelPut(int x, int y, uint32_t color) noexcept + void GraphicsSupport::pixelPut(int x, int y, std::uint32_t color) noexcept { MLX_PROFILE_FUNCTION(); _pixel_put_pipeline.setPixel(x, y, color); } - void GraphicsSupport::stringPut(int x, int y, uint32_t color, std::string str) + void GraphicsSupport::stringPut(int x, int y, std::uint32_t color, std::string str) { MLX_PROFILE_FUNCTION(); std::pair res = _text_manager.registerText(x, y, color, str); diff --git a/src/platform/inputs.cpp b/src/platform/inputs.cpp index cc826f9..40adb8f 100644 --- a/src/platform/inputs.cpp +++ b/src/platform/inputs.cpp @@ -33,7 +33,7 @@ namespace mlx _yRel = _event.motion.yrel; } - uint32_t id = _event.window.windowID; + std::uint32_t id = _event.window.windowID; if(_events_hooks.find(id) == _events_hooks.end()) continue; auto& hooks = _events_hooks[id]; diff --git a/src/platform/inputs.h b/src/platform/inputs.h index e550009..6a575bb 100644 --- a/src/platform/inputs.h +++ b/src/platform/inputs.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/05 16:27:35 by maldavid #+# #+# */ -/* Updated: 2024/01/16 07:59:08 by maldavid ### ########.fr */ +/* Updated: 2024/02/25 07:51:55 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ @@ -44,7 +44,7 @@ namespace mlx inline int getXRel() const noexcept { return _xRel; } inline int getYRel() const noexcept { return _yRel; } - inline bool is_running() const noexcept { return !_end; } + inline bool isRunning() const noexcept { return !_end; } inline constexpr void finish() noexcept { _end = true; } inline void addWindow(std::shared_ptr window) @@ -53,7 +53,7 @@ namespace mlx _events_hooks[window->getID()] = {}; } - inline void onEvent(uint32_t id, int event, int (*funct_ptr)(int, void*), void* param) noexcept + inline void onEvent(std::uint32_t id, int event, int (*funct_ptr)(int, void*), void* param) noexcept { _events_hooks[id][event].hook = funct_ptr; _events_hooks[id][event].param = param; @@ -62,8 +62,8 @@ namespace mlx ~Input() = default; private: - std::unordered_map> _windows; - std::unordered_map> _events_hooks; + std::unordered_map> _windows; + std::unordered_map> _events_hooks; SDL_Event _event; int _x = 0; diff --git a/src/platform/window.cpp b/src/platform/window.cpp index 44827ac..65e94d9 100644 --- a/src/platform/window.cpp +++ b/src/platform/window.cpp @@ -17,15 +17,15 @@ namespace mlx { #if SDL_BYTEORDER == SDL_BIG_ENDIAN - constexpr const uint32_t rmask = 0xff000000; - constexpr const uint32_t gmask = 0x00ff0000; - constexpr const uint32_t bmask = 0x0000ff00; - constexpr const uint32_t amask = 0x000000ff; + constexpr const std::uint32_t rmask = 0xff000000; + constexpr const std::uint32_t gmask = 0x00ff0000; + constexpr const std::uint32_t bmask = 0x0000ff00; + constexpr const std::uint32_t amask = 0x000000ff; #else - constexpr const uint32_t rmask = 0x000000ff; - constexpr const uint32_t gmask = 0x0000ff00; - constexpr const uint32_t bmask = 0x00ff0000; - constexpr const uint32_t amask = 0xff000000; + constexpr const std::uint32_t rmask = 0x000000ff; + constexpr const std::uint32_t gmask = 0x0000ff00; + constexpr const std::uint32_t bmask = 0x00ff0000; + constexpr const std::uint32_t amask = 0xff000000; #endif MLX_Window::MLX_Window(std::size_t w, std::size_t h, const std::string& title) : _width(w), _height(h) diff --git a/src/platform/window.h b/src/platform/window.h index 876c14b..dfe0924 100644 --- a/src/platform/window.h +++ b/src/platform/window.h @@ -27,7 +27,7 @@ namespace mlx inline SDL_Window* getNativeWindow() const noexcept { return _win; } inline int getWidth() const noexcept { return _width; } inline int getHeight() const noexcept { return _height; } - inline uint32_t getID() const noexcept { return _id; } + inline std::uint32_t getID() const noexcept { return _id; } void destroy() noexcept; @@ -38,7 +38,7 @@ namespace mlx SDL_Window* _win = nullptr; int _width = 0; int _height = 0; - uint32_t _id = -1; + std::uint32_t _id = -1; }; } diff --git a/src/renderer/buffers/vk_ibo.h b/src/renderer/buffers/vk_ibo.h index f368e13..7acc988 100644 --- a/src/renderer/buffers/vk_ibo.h +++ b/src/renderer/buffers/vk_ibo.h @@ -23,7 +23,7 @@ namespace mlx class C_IBO : public Buffer { public: - inline void create(uint32_t size, const uint16_t* data, const char* name) { Buffer::create(Buffer::kind::constant, size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, name, data); } + inline void create(std::uint32_t size, const std::uint16_t* data, const char* name) { Buffer::create(Buffer::kind::constant, size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, name, data); } inline void bind(Renderer& renderer) noexcept { renderer.getActiveCmdBuffer().bindIndexBuffer(*this); } }; } diff --git a/src/renderer/buffers/vk_ubo.cpp b/src/renderer/buffers/vk_ubo.cpp index 686663f..996516c 100644 --- a/src/renderer/buffers/vk_ubo.cpp +++ b/src/renderer/buffers/vk_ubo.cpp @@ -17,7 +17,7 @@ namespace mlx { - void UBO::create(Renderer* renderer, uint32_t size, [[maybe_unused]] const char* name) + void UBO::create(Renderer* renderer, std::uint32_t size, [[maybe_unused]] const char* name) { MLX_PROFILE_FUNCTION(); _renderer = renderer; @@ -37,16 +37,16 @@ namespace mlx } } - void UBO::setData(uint32_t size, const void* data) + void UBO::setData(std::uint32_t size, const void* data) { MLX_PROFILE_FUNCTION(); - std::memcpy(_maps[_renderer->getActiveImageIndex()], data, static_cast(size)); + std::memcpy(_maps[_renderer->getActiveImageIndex()], data, static_cast(size)); } - void UBO::setDynamicData(uint32_t size, const void* data) + void UBO::setDynamicData(std::uint32_t size, const void* data) { MLX_PROFILE_FUNCTION(); - std::memcpy(_maps[_renderer->getActiveImageIndex()], data, static_cast(size)); + std::memcpy(_maps[_renderer->getActiveImageIndex()], data, static_cast(size)); _buffers[_renderer->getActiveImageIndex()].flush(); } diff --git a/src/renderer/buffers/vk_ubo.h b/src/renderer/buffers/vk_ubo.h index 6dcdc21..74a7fd9 100644 --- a/src/renderer/buffers/vk_ubo.h +++ b/src/renderer/buffers/vk_ubo.h @@ -23,10 +23,10 @@ namespace mlx class UBO { public: - void create(class Renderer* renderer, uint32_t size, const char* name); + void create(class Renderer* renderer, std::uint32_t size, const char* name); - void setData(uint32_t size, const void* data); - void setDynamicData(uint32_t size, const void* data); + void setData(std::uint32_t size, const void* data); + void setDynamicData(std::uint32_t size, const void* data); void destroy() noexcept; diff --git a/src/renderer/buffers/vk_vbo.cpp b/src/renderer/buffers/vk_vbo.cpp index 8ceab7d..ec17a88 100644 --- a/src/renderer/buffers/vk_vbo.cpp +++ b/src/renderer/buffers/vk_vbo.cpp @@ -15,7 +15,7 @@ namespace mlx { - void VBO::setData(uint32_t size, const void* data) + void VBO::setData(std::uint32_t size, const void* data) { if(size > getSize()) { @@ -28,11 +28,11 @@ namespace mlx void* temp = nullptr; mapMem(&temp); - std::memcpy(temp, data, static_cast(size)); + std::memcpy(temp, data, static_cast(size)); unmapMem(); } - void D_VBO::setData(uint32_t size, const void* data) + void D_VBO::setData(std::uint32_t size, const void* data) { if(size > getSize()) { diff --git a/src/renderer/buffers/vk_vbo.h b/src/renderer/buffers/vk_vbo.h index 9079eea..88d0023 100644 --- a/src/renderer/buffers/vk_vbo.h +++ b/src/renderer/buffers/vk_vbo.h @@ -22,23 +22,23 @@ namespace mlx class VBO : public Buffer { public: - inline void create(uint32_t size, const void* data, const char* name) { Buffer::create(Buffer::kind::dynamic, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, name, data); } - void setData(uint32_t size, const void* data); + inline void create(std::uint32_t size, const void* data, const char* name) { Buffer::create(Buffer::kind::dynamic, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, name, data); } + void setData(std::uint32_t size, const void* data); inline void bind(Renderer& renderer) noexcept { renderer.getActiveCmdBuffer().bindVertexBuffer(*this); } }; class D_VBO : public Buffer { public: - inline void create(uint32_t size, const void* data, const char* name) { Buffer::create(Buffer::kind::dynamic_device_local, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, name, data); } - void setData(uint32_t size, const void* data); + inline void create(std::uint32_t size, const void* data, const char* name) { Buffer::create(Buffer::kind::dynamic_device_local, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, name, data); } + void setData(std::uint32_t size, const void* data); inline void bind(Renderer& renderer) noexcept { renderer.getActiveCmdBuffer().bindVertexBuffer(*this); } }; class C_VBO : public Buffer { public: - inline void create(uint32_t size, const void* data, const char* name) { Buffer::create(Buffer::kind::constant, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, name, data); } + inline void create(std::uint32_t size, const void* data, const char* name) { Buffer::create(Buffer::kind::constant, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, name, data); } inline void bind(Renderer& renderer) noexcept { renderer.getActiveCmdBuffer().bindVertexBuffer(*this); } }; } diff --git a/src/renderer/command/single_time_cmd_manager.h b/src/renderer/command/single_time_cmd_manager.h index ea7330c..271fdf9 100644 --- a/src/renderer/command/single_time_cmd_manager.h +++ b/src/renderer/command/single_time_cmd_manager.h @@ -39,7 +39,7 @@ namespace mlx ~SingleTimeCmdManager() = default; - inline static constexpr const uint8_t BASE_POOL_SIZE = 16; + inline static constexpr const std::uint8_t BASE_POOL_SIZE = 16; private: std::vector _buffers; diff --git a/src/renderer/command/vk_cmd_buffer.cpp b/src/renderer/command/vk_cmd_buffer.cpp index 1ffc118..d1b208b 100644 --- a/src/renderer/command/vk_cmd_buffer.cpp +++ b/src/renderer/command/vk_cmd_buffer.cpp @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/06 18:26:06 by maldavid #+# #+# */ -/* Updated: 2024/01/10 18:30:04 by maldavid ### ########.fr */ +/* Updated: 2024/02/25 08:02:26 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/src/renderer/core/memory.cpp b/src/renderer/core/memory.cpp index ccb8ed0..8a5c317 100644 --- a/src/renderer/core/memory.cpp +++ b/src/renderer/core/memory.cpp @@ -94,7 +94,7 @@ namespace mlx core::error::report(e_kind::fatal_error, "Graphics allocator : failed to allocate a buffer, %s", RCore::verbaliseResultVk(res)); if(name != nullptr) { - Render_Core::get().getLayers().setDebugUtilsObjectNameEXT(VK_OBJECT_TYPE_BUFFER, (uint64_t)buffer, name); + Render_Core::get().getLayers().setDebugUtilsObjectNameEXT(VK_OBJECT_TYPE_BUFFER, (std::uint64_t)buffer, name); vmaSetAllocationName(_allocator, allocation, name); } #ifdef DEBUG @@ -124,7 +124,7 @@ namespace mlx core::error::report(e_kind::fatal_error, "Graphics allocator : failed to allocate an image, %s", RCore::verbaliseResultVk(res)); if(name != nullptr) { - Render_Core::get().getLayers().setDebugUtilsObjectNameEXT(VK_OBJECT_TYPE_IMAGE, (uint64_t)image, name); + Render_Core::get().getLayers().setDebugUtilsObjectNameEXT(VK_OBJECT_TYPE_IMAGE, (std::uint64_t)image, name); vmaSetAllocationName(_allocator, allocation, name); } #ifdef DEBUG @@ -161,7 +161,7 @@ namespace mlx void GPUallocator::dumpMemoryToJson() { - static uint32_t id = 0; + static std::uint32_t id = 0; std::string name("memory_dump"); name.append(std::to_string(id) + ".json"); std::ofstream file(name); diff --git a/src/renderer/core/memory.h b/src/renderer/core/memory.h index f977ace..077fd1b 100644 --- a/src/renderer/core/memory.h +++ b/src/renderer/core/memory.h @@ -44,8 +44,8 @@ namespace mlx private: VmaAllocator _allocator; - uint32_t _active_buffers_allocations = 0; - uint32_t _active_images_allocations = 0; + std::uint32_t _active_buffers_allocations = 0; + std::uint32_t _active_images_allocations = 0; }; } diff --git a/src/renderer/core/render_core.cpp b/src/renderer/core/render_core.cpp index 9341f6e..1de3720 100644 --- a/src/renderer/core/render_core.cpp +++ b/src/renderer/core/render_core.cpp @@ -28,12 +28,12 @@ namespace mlx { namespace RCore { - std::optional findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties, bool error) + std::optional findMemoryType(std::uint32_t typeFilter, VkMemoryPropertyFlags properties, bool error) { VkPhysicalDeviceMemoryProperties memProperties; vkGetPhysicalDeviceMemoryProperties(Render_Core::get().getDevice().getPhysicalDevice(), &memProperties); - for(uint32_t i = 0; i < memProperties.memoryTypeCount; i++) + for(std::uint32_t i = 0; i < memProperties.memoryTypeCount; i++) { if((typeFilter & (1 << i)) && (memProperties.memoryTypes[i].propertyFlags & properties) == properties) return i; diff --git a/src/renderer/core/render_core.h b/src/renderer/core/render_core.h index aa279f9..cf4aae5 100644 --- a/src/renderer/core/render_core.h +++ b/src/renderer/core/render_core.h @@ -33,7 +33,7 @@ namespace mlx { namespace RCore { - std::optional findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties, bool error = true); + std::optional findMemoryType(std::uint32_t typeFilter, VkMemoryPropertyFlags properties, bool error = true); const char* verbaliseResultVk(VkResult result); VkPipelineStageFlags accessFlagsToPipelineStage(VkAccessFlags accessFlags, VkPipelineStageFlags stageFlags); } diff --git a/src/renderer/core/vk_device.cpp b/src/renderer/core/vk_device.cpp index befcba2..37d5ae1 100644 --- a/src/renderer/core/vk_device.cpp +++ b/src/renderer/core/vk_device.cpp @@ -31,10 +31,10 @@ namespace mlx Queues::QueueFamilyIndices indices = Render_Core::get().getQueue().getFamilies(); std::vector queueCreateInfos; - std::set uniqueQueueFamilies = { indices.graphicsFamily.value(), indices.presentFamily.value() }; + std::set uniqueQueueFamilies = { indices.graphicsFamily.value(), indices.presentFamily.value() }; float queuePriority = 1.0f; - for(uint32_t queueFamily : uniqueQueueFamilies) + for(std::uint32_t queueFamily : uniqueQueueFamilies) { VkDeviceQueueCreateInfo queueCreateInfo{}; queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; @@ -49,12 +49,12 @@ namespace mlx VkDeviceCreateInfo createInfo{}; createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; - createInfo.queueCreateInfoCount = static_cast(queueCreateInfos.size()); + createInfo.queueCreateInfoCount = static_cast(queueCreateInfos.size()); createInfo.pQueueCreateInfos = queueCreateInfos.data(); createInfo.pEnabledFeatures = &deviceFeatures; - createInfo.enabledExtensionCount = static_cast(deviceExtensions.size()); + createInfo.enabledExtensionCount = static_cast(deviceExtensions.size()); createInfo.ppEnabledExtensionNames = deviceExtensions.data(); createInfo.enabledLayerCount = 0; @@ -68,7 +68,7 @@ namespace mlx void Device::pickPhysicalDevice() { - uint32_t deviceCount = 0; + std::uint32_t deviceCount = 0; vkEnumeratePhysicalDevices(Render_Core::get().getInstance().get(), &deviceCount, nullptr); if(deviceCount == 0) @@ -113,7 +113,7 @@ namespace mlx Queues::QueueFamilyIndices indices = Render_Core::get().getQueue().findQueueFamilies(device, surface); bool extensionsSupported = checkDeviceExtensionSupport(device); - uint32_t formatCount = 0; + std::uint32_t formatCount = 0; if(extensionsSupported) vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr); @@ -144,7 +144,7 @@ namespace mlx bool Device::checkDeviceExtensionSupport(VkPhysicalDevice device) { - uint32_t extensionCount; + std::uint32_t extensionCount; vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr); std::vector availableExtensions(extensionCount); diff --git a/src/renderer/core/vk_fence.cpp b/src/renderer/core/vk_fence.cpp index 2e2d5a4..f63df12 100644 --- a/src/renderer/core/vk_fence.cpp +++ b/src/renderer/core/vk_fence.cpp @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/04/02 17:53:06 by maldavid #+# #+# */ -/* Updated: 2024/01/06 16:57:26 by maldavid ### ########.fr */ +/* Updated: 2024/02/25 08:02:45 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/src/renderer/core/vk_instance.cpp b/src/renderer/core/vk_instance.cpp index 013e387..040f9d8 100644 --- a/src/renderer/core/vk_instance.cpp +++ b/src/renderer/core/vk_instance.cpp @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/08 19:04:21 by maldavid #+# #+# */ -/* Updated: 2024/02/24 04:31:00 by maldavid ### ########.fr */ +/* Updated: 2024/02/24 21:10:32 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ @@ -22,7 +22,7 @@ namespace mlx VkApplicationInfo appInfo{}; appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; appInfo.pEngineName = "MacroLibX"; - appInfo.engineVersion = VK_MAKE_VERSION(1, 2, 1); + appInfo.engineVersion = VK_MAKE_VERSION(1, 3, 1); appInfo.apiVersion = VK_API_VERSION_1_2; auto extensions = getRequiredExtensions(); @@ -30,7 +30,7 @@ namespace mlx VkInstanceCreateInfo createInfo{}; createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; createInfo.pApplicationInfo = &appInfo; - createInfo.enabledExtensionCount = static_cast(extensions.size()); + createInfo.enabledExtensionCount = static_cast(extensions.size()); createInfo.ppEnabledExtensionNames = extensions.data(); createInfo.enabledLayerCount = 0; // will be replaced if validation layers are enabled createInfo.pNext = nullptr; @@ -40,7 +40,7 @@ namespace mlx { if(Render_Core::get().getLayers().checkValidationLayerSupport()) { - createInfo.enabledLayerCount = static_cast(validationLayers.size()); + createInfo.enabledLayerCount = static_cast(validationLayers.size()); createInfo.ppEnabledLayerNames = validationLayers.data(); Render_Core::get().getLayers().populateDebugMessengerCreateInfo(debugCreateInfo); createInfo.pNext = static_cast(&debugCreateInfo); diff --git a/src/renderer/core/vk_queues.cpp b/src/renderer/core/vk_queues.cpp index 7928cc3..89cfb3d 100644 --- a/src/renderer/core/vk_queues.cpp +++ b/src/renderer/core/vk_queues.cpp @@ -18,7 +18,7 @@ namespace mlx { Queues::QueueFamilyIndices Queues::findQueueFamilies(VkPhysicalDevice device, VkSurfaceKHR surface) { - uint32_t queueFamilyCount = 0; + std::uint32_t queueFamilyCount = 0; vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr); std::vector queueFamilies(queueFamilyCount); diff --git a/src/renderer/core/vk_queues.h b/src/renderer/core/vk_queues.h index 4def156..d3d1c28 100644 --- a/src/renderer/core/vk_queues.h +++ b/src/renderer/core/vk_queues.h @@ -26,8 +26,8 @@ namespace mlx public: struct QueueFamilyIndices { - std::optional graphicsFamily; - std::optional presentFamily; + std::optional graphicsFamily; + std::optional presentFamily; inline bool isComplete() { return graphicsFamily.has_value() && presentFamily.has_value(); } }; diff --git a/src/renderer/core/vk_validation_layers.cpp b/src/renderer/core/vk_validation_layers.cpp index 5b0cbea..e19553a 100644 --- a/src/renderer/core/vk_validation_layers.cpp +++ b/src/renderer/core/vk_validation_layers.cpp @@ -25,7 +25,7 @@ namespace mlx if constexpr(!enableValidationLayers) return; - uint32_t extensionCount; + std::uint32_t extensionCount; vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr); std::vector extensions(extensionCount); vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensions.data()); @@ -56,7 +56,7 @@ namespace mlx bool ValidationLayers::checkValidationLayerSupport() { - uint32_t layerCount; + std::uint32_t layerCount; vkEnumerateInstanceLayerProperties(&layerCount, nullptr); std::vector availableLayers(layerCount); @@ -73,7 +73,7 @@ namespace mlx }); } - VkResult ValidationLayers::setDebugUtilsObjectNameEXT(VkObjectType object_type, uint64_t object_handle, const char* object_name) + VkResult ValidationLayers::setDebugUtilsObjectNameEXT(VkObjectType object_type, std::uint64_t object_handle, const char* object_name) { if(!real_vkSetDebugUtilsObjectNameEXT) return VK_ERROR_EXTENSION_NOT_PRESENT; diff --git a/src/renderer/core/vk_validation_layers.h b/src/renderer/core/vk_validation_layers.h index 5ea19b8..7247ede 100644 --- a/src/renderer/core/vk_validation_layers.h +++ b/src/renderer/core/vk_validation_layers.h @@ -29,7 +29,7 @@ namespace mlx bool checkValidationLayerSupport(); void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo); - VkResult setDebugUtilsObjectNameEXT(VkObjectType object_type, uint64_t object_handle, const char* object_name); + VkResult setDebugUtilsObjectNameEXT(VkObjectType object_type, std::uint64_t object_handle, const char* object_name); ~ValidationLayers() = default; diff --git a/src/renderer/descriptors/vk_descriptor_set.cpp b/src/renderer/descriptors/vk_descriptor_set.cpp index ae4662b..819ba25 100644 --- a/src/renderer/descriptors/vk_descriptor_set.cpp +++ b/src/renderer/descriptors/vk_descriptor_set.cpp @@ -36,7 +36,7 @@ namespace mlx VkDescriptorSetAllocateInfo allocInfo{}; allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; allocInfo.descriptorPool = _pool->get(); - allocInfo.descriptorSetCount = static_cast(MAX_FRAMES_IN_FLIGHT); + allocInfo.descriptorSetCount = static_cast(MAX_FRAMES_IN_FLIGHT); allocInfo.pSetLayouts = layouts.data(); VkResult res = vkAllocateDescriptorSets(device, &allocInfo, _desc_set.data()); diff --git a/src/renderer/images/texture.cpp b/src/renderer/images/texture.cpp index 1fe116f..cded232 100644 --- a/src/renderer/images/texture.cpp +++ b/src/renderer/images/texture.cpp @@ -30,7 +30,7 @@ namespace mlx { - void Texture::create(uint8_t* pixels, uint32_t width, uint32_t height, VkFormat format, const char* name, bool dedicated_memory) + void Texture::create(std::uint8_t* pixels, std::uint32_t width, std::uint32_t height, VkFormat format, const char* name, bool dedicated_memory) { MLX_PROFILE_FUNCTION(); Image::create(width, height, format, TILING, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, name, dedicated_memory); @@ -45,15 +45,15 @@ namespace mlx {{0, height}, {1.f, 1.f, 1.f, 1.f}, {0.0f, 1.0f}} }; - std::vector indexData = { 0, 1, 2, 2, 3, 0 }; + std::vector indexData = { 0, 1, 2, 2, 3, 0 }; #ifdef DEBUG _vbo.create(sizeof(Vertex) * vertexData.size(), vertexData.data(), name); - _ibo.create(sizeof(uint16_t) * indexData.size(), indexData.data(), name); + _ibo.create(sizeof(std::uint16_t) * indexData.size(), indexData.data(), name); _name = name; #else _vbo.create(sizeof(Vertex) * vertexData.size(), vertexData.data(), nullptr); - _ibo.create(sizeof(uint16_t) * indexData.size(), indexData.data(), nullptr); + _ibo.create(sizeof(std::uint16_t) * indexData.size(), indexData.data(), nullptr); #endif Buffer staging_buffer; @@ -68,7 +68,7 @@ namespace mlx } else { - std::vector default_pixels(width * height, 0x00000000); + std::vector default_pixels(width * height, 0x00000000); #ifdef DEBUG staging_buffer.create(Buffer::kind::dynamic, size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, name, default_pixels.data()); #else @@ -79,10 +79,10 @@ namespace mlx staging_buffer.destroy(); } - void Texture::setPixel(int x, int y, uint32_t color) noexcept + void Texture::setPixel(int x, int y, std::uint32_t color) noexcept { MLX_PROFILE_FUNCTION(); - if(x < 0 || y < 0 || static_cast(x) > getWidth() || static_cast(y) > getHeight()) + if(x < 0 || y < 0 || static_cast(x) > getWidth() || static_cast(y) > getHeight()) return; if(_map == nullptr) openCPUmap(); @@ -93,13 +93,13 @@ namespace mlx int Texture::getPixel(int x, int y) noexcept { MLX_PROFILE_FUNCTION(); - if(x < 0 || y < 0 || static_cast(x) > getWidth() || static_cast(y) > getHeight()) + if(x < 0 || y < 0 || static_cast(x) > getWidth() || static_cast(y) > getHeight()) return 0; if(_map == nullptr) openCPUmap(); - uint32_t color = _cpu_map[(y * getWidth()) + x]; - uint8_t* bytes = reinterpret_cast(&color); - uint8_t tmp = bytes[0]; + std::uint32_t color = _cpu_map[(y * getWidth()) + x]; + std::uint8_t* bytes = reinterpret_cast(&color); + std::uint8_t tmp = bytes[0]; bytes[0] = bytes[2]; bytes[2] = tmp; return *reinterpret_cast(bytes); @@ -123,7 +123,7 @@ namespace mlx #endif Image::copyToBuffer(*_buf_map); _buf_map->mapMem(&_map); - _cpu_map = std::vector(getWidth() * getHeight(), 0); + _cpu_map = std::vector(getWidth() * getHeight(), 0); std::memcpy(_cpu_map.data(), _map, size); #ifdef DEBUG core::error::report(e_kind::message, "Texture : mapped CPU memory using staging buffer"); @@ -152,7 +152,7 @@ namespace mlx vkCmdPushConstants(cmd.get(), renderer.getPipeline().getPipelineLayout(), VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(translate), &translate); sets[1] = _set.get(); vkCmdBindDescriptorSets(renderer.getActiveCmdBuffer().get(), VK_PIPELINE_BIND_POINT_GRAPHICS, renderer.getPipeline().getPipelineLayout(), 0, sets.size(), sets.data(), 0, nullptr); - vkCmdDrawIndexed(cmd.get(), static_cast(_ibo.getSize() / sizeof(uint16_t)), 1, 0, 0, 0); + vkCmdDrawIndexed(cmd.get(), static_cast(_ibo.getSize() / sizeof(std::uint16_t)), 1, 0, 0, 0); } void Texture::destroy() noexcept @@ -171,7 +171,7 @@ namespace mlx MLX_PROFILE_FUNCTION(); Texture texture; int channels; - uint8_t* data = nullptr; + std::uint8_t* data = nullptr; std::string filename = file.string(); if(!std::filesystem::exists(std::move(file))) diff --git a/src/renderer/images/texture.h b/src/renderer/images/texture.h index 5558886..be48db0 100644 --- a/src/renderer/images/texture.h +++ b/src/renderer/images/texture.h @@ -31,11 +31,11 @@ namespace mlx public: Texture() = default; - void create(uint8_t* pixels, uint32_t width, uint32_t height, VkFormat format, const char* name, bool dedicated_memory = false); + void create(std::uint8_t* pixels, std::uint32_t width, std::uint32_t height, VkFormat format, const char* name, bool dedicated_memory = false); void render(std::array& sets, class Renderer& renderer, int x, int y); void destroy() noexcept override; - void setPixel(int x, int y, uint32_t color) noexcept; + void setPixel(int x, int y, std::uint32_t color) noexcept; int getPixel(int x, int y) noexcept; inline void setDescriptor(DescriptorSet&& set) noexcept { _set = set; } @@ -56,7 +56,7 @@ namespace mlx std::string _name; #endif DescriptorSet _set; - std::vector _cpu_map; + std::vector _cpu_map; std::optional _buf_map = std::nullopt; void* _map = nullptr; bool _has_been_modified = false; diff --git a/src/renderer/images/texture_atlas.cpp b/src/renderer/images/texture_atlas.cpp index c03d712..fc06315 100644 --- a/src/renderer/images/texture_atlas.cpp +++ b/src/renderer/images/texture_atlas.cpp @@ -20,7 +20,7 @@ namespace mlx { - void TextureAtlas::create(uint8_t* pixels, uint32_t width, uint32_t height, VkFormat format, const char* name, bool dedicated_memory) + void TextureAtlas::create(std::uint8_t* pixels, std::uint32_t width, std::uint32_t height, VkFormat format, const char* name, bool dedicated_memory) { Image::create(width, height, format, TILING, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, name, dedicated_memory); Image::createImageView(VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_COLOR_BIT); @@ -39,13 +39,13 @@ namespace mlx staging_buffer.destroy(); } - void TextureAtlas::render(Renderer& renderer, int x, int y, uint32_t ibo_size) const + void TextureAtlas::render(Renderer& renderer, int x, int y, std::uint32_t ibo_size) const { auto cmd = renderer.getActiveCmdBuffer().get(); glm::vec2 translate(x, y); vkCmdPushConstants(cmd, renderer.getPipeline().getPipelineLayout(), VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(translate), &translate); - vkCmdDrawIndexed(cmd, ibo_size / sizeof(uint16_t), 1, 0, 0, 0); + vkCmdDrawIndexed(cmd, ibo_size / sizeof(std::uint16_t), 1, 0, 0, 0); } void TextureAtlas::destroy() noexcept diff --git a/src/renderer/images/texture_atlas.h b/src/renderer/images/texture_atlas.h index bc465d7..2165879 100644 --- a/src/renderer/images/texture_atlas.h +++ b/src/renderer/images/texture_atlas.h @@ -25,8 +25,8 @@ namespace mlx public: TextureAtlas() = default; - void create(uint8_t* pixels, uint32_t width, uint32_t height, VkFormat format, const char* name, bool dedicated_memory = false); - void render(class Renderer& renderer, int x, int y, uint32_t ibo_size) const; + void create(std::uint8_t* pixels, std::uint32_t width, std::uint32_t height, VkFormat format, const char* name, bool dedicated_memory = false); + void render(class Renderer& renderer, int x, int y, std::uint32_t ibo_size) const; void destroy() noexcept override; inline void setDescriptor(DescriptorSet&& set) noexcept { _set = set; } diff --git a/src/renderer/images/vk_image.cpp b/src/renderer/images/vk_image.cpp index 412387e..3eecbf2 100644 --- a/src/renderer/images/vk_image.cpp +++ b/src/renderer/images/vk_image.cpp @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/01/25 11:59:07 by maldavid #+# #+# */ -/* Updated: 2024/01/18 09:47:26 by maldavid ### ########.fr */ +/* Updated: 2024/02/25 08:03:47 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ @@ -45,7 +45,7 @@ namespace mlx } } - VkFormat bitsToFormat(uint32_t bits) + VkFormat bitsToFormat(std::uint32_t bits) { switch(bits) { @@ -99,7 +99,7 @@ namespace mlx return accessMask; } - void Image::create(uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, const char* name, bool dedicated_memory) + void Image::create(std::uint32_t width, std::uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, const char* name, bool dedicated_memory) { _width = width; _height = height; @@ -153,7 +153,7 @@ namespace mlx core::error::report(e_kind::fatal_error, "Vulkan : failed to create an image view, %s", RCore::verbaliseResultVk(res)); #ifdef DEBUG else - Render_Core::get().getLayers().setDebugUtilsObjectNameEXT(VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t)_image_view, _name.c_str()); + Render_Core::get().getLayers().setDebugUtilsObjectNameEXT(VK_OBJECT_TYPE_IMAGE_VIEW, (std::uint64_t)_image_view, _name.c_str()); #endif } @@ -177,7 +177,7 @@ namespace mlx core::error::report(e_kind::fatal_error, "Vulkan : failed to create an image sampler, %s", RCore::verbaliseResultVk(res)); #ifdef DEBUG else - Render_Core::get().getLayers().setDebugUtilsObjectNameEXT(VK_OBJECT_TYPE_SAMPLER, (uint64_t)_sampler, _name.c_str()); + Render_Core::get().getLayers().setDebugUtilsObjectNameEXT(VK_OBJECT_TYPE_SAMPLER, (std::uint64_t)_sampler, _name.c_str()); #endif } @@ -264,7 +264,7 @@ namespace mlx //CmdResource::requireDestroy(); } - uint32_t formatSize(VkFormat format) + std::uint32_t formatSize(VkFormat format) { switch(format) { diff --git a/src/renderer/images/vk_image.h b/src/renderer/images/vk_image.h index 76c2108..017ec41 100644 --- a/src/renderer/images/vk_image.h +++ b/src/renderer/images/vk_image.h @@ -26,10 +26,10 @@ namespace mlx { - uint32_t formatSize(VkFormat format); + std::uint32_t formatSize(VkFormat format); bool isStencilFormat(VkFormat format); bool isDepthFormat(VkFormat format); - VkFormat bitsToFormat(uint32_t bits); + VkFormat bitsToFormat(std::uint32_t bits); VkPipelineStageFlags layoutToAccessMask(VkImageLayout layout, bool isDestination); class Image : public CmdResource @@ -39,7 +39,7 @@ namespace mlx public: Image() = default; - inline void create(VkImage image, VkFormat format, uint32_t width, uint32_t height, VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED) noexcept + inline void create(VkImage image, VkFormat format, std::uint32_t width, std::uint32_t height, VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED) noexcept { _image = image; _format = format; @@ -47,7 +47,7 @@ namespace mlx _height = height; _layout = layout; } - void create(uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, const char* name, bool decated_memory = false); + void create(std::uint32_t width, std::uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, const char* name, bool decated_memory = false); void createImageView(VkImageViewType type, VkImageAspectFlags aspectFlags) noexcept; void createSampler() noexcept; void copyFromBuffer(class Buffer& buffer); @@ -62,8 +62,8 @@ namespace mlx inline VkImageTiling getTiling() const noexcept { return _tiling; } inline VkImageLayout getLayout() const noexcept { return _layout; } inline VkSampler getSampler() const noexcept { return _sampler; } - inline uint32_t getWidth() const noexcept { return _width; } - inline uint32_t getHeight() const noexcept { return _height; } + inline std::uint32_t getWidth() const noexcept { return _width; } + inline std::uint32_t getHeight() const noexcept { return _height; } inline bool isInit() const noexcept { return _image != VK_NULL_HANDLE; } virtual ~Image() = default; @@ -83,8 +83,8 @@ namespace mlx VkFormat _format; VkImageTiling _tiling; VkImageLayout _layout = VK_IMAGE_LAYOUT_UNDEFINED; - uint32_t _width = 0; - uint32_t _height = 0; + std::uint32_t _width = 0; + std::uint32_t _height = 0; }; } diff --git a/src/renderer/pipeline/pipeline.cpp b/src/renderer/pipeline/pipeline.cpp index 06ebfd3..00291fc 100644 --- a/src/renderer/pipeline/pipeline.cpp +++ b/src/renderer/pipeline/pipeline.cpp @@ -49,7 +49,7 @@ namespace mlx gl_Position = uProj.mat * vec4(pos.x, pos.y, 0.0, 1.0); } */ - const std::vector vertex_shader = { // precompiled vertex shader + const std::vector vertex_shader = { // precompiled vertex shader 0x07230203,0x00010000,0x0008000b,0x0000003b,0x00000000,0x00020011,0x00000001,0x0006000b, 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, 0x000a000f,0x00000000,0x00000004,0x6e69616d,0x00000000,0x0000000b,0x0000000f,0x00000015, @@ -124,7 +124,7 @@ namespace mlx fColor = process_color; } */ - const std::vector fragment_shader = { // pre compiled fragment shader + const std::vector fragment_shader = { // pre compiled fragment shader 0x07230203,0x00010000,0x0008000b,0x0000002c,0x00000000,0x00020011,0x00000001,0x0006000b, 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, 0x0007000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x0000000d,0x0000002a,0x00030010, @@ -164,7 +164,7 @@ namespace mlx { VkShaderModuleCreateInfo createInfo{}; createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; - createInfo.codeSize = vertex_shader.size() * sizeof(uint32_t); + createInfo.codeSize = vertex_shader.size() * sizeof(std::uint32_t); createInfo.pCode = vertex_shader.data(); VkShaderModule vshader; if(vkCreateShaderModule(Render_Core::get().getDevice().get(), &createInfo, nullptr, &vshader) != VK_SUCCESS) @@ -176,7 +176,7 @@ namespace mlx push_constant.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; - createInfo.codeSize = fragment_shader.size() * sizeof(uint32_t); + createInfo.codeSize = fragment_shader.size() * sizeof(std::uint32_t); createInfo.pCode = fragment_shader.data(); VkShaderModule fshader; if(vkCreateShaderModule(Render_Core::get().getDevice().get(), &createInfo, nullptr, &fshader) != VK_SUCCESS) @@ -203,7 +203,7 @@ namespace mlx vertexInputStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; vertexInputStateCreateInfo.vertexBindingDescriptionCount = 1; vertexInputStateCreateInfo.pVertexBindingDescriptions = &bindingDescription; - vertexInputStateCreateInfo.vertexAttributeDescriptionCount = static_cast(attributeDescriptions.size()); + vertexInputStateCreateInfo.vertexAttributeDescriptionCount = static_cast(attributeDescriptions.size()); vertexInputStateCreateInfo.pVertexAttributeDescriptions = attributeDescriptions.data(); VkPipelineInputAssemblyStateCreateInfo inputAssembly{}; @@ -213,7 +213,7 @@ namespace mlx VkDynamicState states[] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR }; - constexpr size_t statesCount = sizeof(states) / sizeof(VkDynamicState); + constexpr std::size_t statesCount = sizeof(states) / sizeof(VkDynamicState); VkPipelineDynamicStateCreateInfo dynamicStates{}; dynamicStates.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; dynamicStates.dynamicStateCount = statesCount; diff --git a/src/renderer/pixel_put.cpp b/src/renderer/pixel_put.cpp index 17ba007..ef2b911 100644 --- a/src/renderer/pixel_put.cpp +++ b/src/renderer/pixel_put.cpp @@ -16,20 +16,20 @@ namespace mlx { - void PixelPutPipeline::init(uint32_t width, uint32_t height, Renderer& renderer) noexcept + void PixelPutPipeline::init(std::uint32_t width, std::uint32_t height, Renderer& renderer) noexcept { MLX_PROFILE_FUNCTION(); _texture.create(nullptr, width, height, VK_FORMAT_R8G8B8A8_UNORM, "__mlx_pixel_put_pipeline_texture", true); _texture.setDescriptor(renderer.getFragDescriptorSet().duplicate()); - _buffer.create(Buffer::kind::dynamic, sizeof(uint32_t) * (width * height), VK_BUFFER_USAGE_TRANSFER_SRC_BIT, "__mlx_pixel_put_pipeline_texture"); + _buffer.create(Buffer::kind::dynamic, sizeof(std::uint32_t) * (width * height), VK_BUFFER_USAGE_TRANSFER_SRC_BIT, "__mlx_pixel_put_pipeline_texture"); _buffer.mapMem(&_buffer_map); - _cpu_map = std::vector(height * width + 1, 0); + _cpu_map = std::vector(height * width + 1, 0); _width = width; _height = height; } - void PixelPutPipeline::setPixel(int x, int y, uint32_t color) noexcept + void PixelPutPipeline::setPixel(int x, int y, std::uint32_t color) noexcept { MLX_PROFILE_FUNCTION(); if(x < 0 || y < 0 || x > static_cast(_width) || y > static_cast(_height)) @@ -50,7 +50,7 @@ namespace mlx MLX_PROFILE_FUNCTION(); if(_has_been_modified) { - std::memcpy(_buffer_map, _cpu_map.data(), sizeof(uint32_t) * _cpu_map.size()); + std::memcpy(_buffer_map, _cpu_map.data(), sizeof(std::uint32_t) * _cpu_map.size()); _texture.copyFromBuffer(_buffer); _has_been_modified = false; } diff --git a/src/renderer/pixel_put.h b/src/renderer/pixel_put.h index b413132..1de58cd 100644 --- a/src/renderer/pixel_put.h +++ b/src/renderer/pixel_put.h @@ -24,9 +24,9 @@ namespace mlx public: PixelPutPipeline() = default; - void init(uint32_t width, uint32_t height, class Renderer& renderer) noexcept; + void init(std::uint32_t width, std::uint32_t height, class Renderer& renderer) noexcept; - void setPixel(int x, int y, uint32_t color) noexcept; + void setPixel(int x, int y, std::uint32_t color) noexcept; void render(std::array& sets, class Renderer& renderer) noexcept; void clear(); @@ -38,10 +38,10 @@ namespace mlx Texture _texture; Buffer _buffer; // using vector as CPU map and not directly writting to mapped buffer to improve performances - std::vector _cpu_map; + std::vector _cpu_map; void* _buffer_map = nullptr; - uint32_t _width = 0; - uint32_t _height = 0; + std::uint32_t _width = 0; + std::uint32_t _height = 0; bool _has_been_modified = true; }; } diff --git a/src/renderer/renderer.cpp b/src/renderer/renderer.cpp index 2a0e1d4..cfe4d42 100644 --- a/src/renderer/renderer.cpp +++ b/src/renderer/renderer.cpp @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/12/18 17:25:16 by maldavid #+# #+# */ -/* Updated: 2024/01/20 08:19:46 by maldavid ### ########.fr */ +/* Updated: 2024/02/25 08:02:05 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/src/renderer/renderer.h b/src/renderer/renderer.h index 007a5ce..219ff03 100644 --- a/src/renderer/renderer.h +++ b/src/renderer/renderer.h @@ -106,8 +106,8 @@ namespace mlx inline DescriptorSet& getFragDescriptorSet() noexcept { return _frag_set; } inline DescriptorSetLayout& getVertDescriptorSetLayout() noexcept { return _vert_layout; } inline DescriptorSetLayout& getFragDescriptorSetLayout() noexcept { return _frag_layout; } - inline uint32_t getActiveImageIndex() noexcept { return _current_frame_index; } - inline uint32_t getImageIndex() noexcept { return _image_index; } + inline std::uint32_t getActiveImageIndex() noexcept { return _current_frame_index; } + inline std::uint32_t getImageIndex() noexcept { return _image_index; } constexpr inline void requireFrameBufferResize() noexcept { _framebufferResized = true; } @@ -136,8 +136,8 @@ namespace mlx class MLX_Window* _window = nullptr; class Texture* _render_target = nullptr; - uint32_t _current_frame_index = 0; - uint32_t _image_index = 0; + std::uint32_t _current_frame_index = 0; + std::uint32_t _image_index = 0; bool _framebufferResized = false; }; } diff --git a/src/renderer/renderpass/vk_framebuffer.h b/src/renderer/renderpass/vk_framebuffer.h index b4db929..275c3e6 100644 --- a/src/renderer/renderpass/vk_framebuffer.h +++ b/src/renderer/renderpass/vk_framebuffer.h @@ -26,13 +26,13 @@ namespace mlx inline VkFramebuffer& operator()() noexcept { return _framebuffer; } inline VkFramebuffer& get() noexcept { return _framebuffer; } - inline uint32_t getWidth() const noexcept { return _width; } - inline uint32_t getHeight() const noexcept { return _height; } + inline std::uint32_t getWidth() const noexcept { return _width; } + inline std::uint32_t getHeight() const noexcept { return _height; } private: VkFramebuffer _framebuffer = VK_NULL_HANDLE; - uint32_t _width = 0; - uint32_t _height = 0; + std::uint32_t _width = 0; + std::uint32_t _height = 0; }; } diff --git a/src/renderer/renderpass/vk_render_pass.cpp b/src/renderer/renderpass/vk_render_pass.cpp index a4a08a1..13a9c01 100644 --- a/src/renderer/renderpass/vk_render_pass.cpp +++ b/src/renderer/renderpass/vk_render_pass.cpp @@ -68,7 +68,7 @@ namespace mlx renderPassInfo.pAttachments = &colorAttachment; renderPassInfo.subpassCount = sizeof(subpasses) / sizeof(VkSubpassDescription); renderPassInfo.pSubpasses = subpasses; - renderPassInfo.dependencyCount = static_cast(subpassesDeps.size()); + renderPassInfo.dependencyCount = static_cast(subpassesDeps.size()); renderPassInfo.pDependencies = subpassesDeps.data(); VkResult res = vkCreateRenderPass(Render_Core::get().getDevice().get(), &renderPassInfo, nullptr, &_renderPass); diff --git a/src/renderer/swapchain/vk_swapchain.cpp b/src/renderer/swapchain/vk_swapchain.cpp index ccd0620..b6b65c7 100644 --- a/src/renderer/swapchain/vk_swapchain.cpp +++ b/src/renderer/swapchain/vk_swapchain.cpp @@ -29,12 +29,12 @@ namespace mlx VkPresentModeKHR presentMode = chooseSwapPresentMode(_swapChainSupport.presentModes); _extent = chooseSwapExtent(_swapChainSupport.capabilities); - uint32_t imageCount = _swapChainSupport.capabilities.minImageCount + 1; + std::uint32_t imageCount = _swapChainSupport.capabilities.minImageCount + 1; if(_swapChainSupport.capabilities.maxImageCount > 0 && imageCount > _swapChainSupport.capabilities.maxImageCount) imageCount = _swapChainSupport.capabilities.maxImageCount; Queues::QueueFamilyIndices indices = Render_Core::get().getQueue().findQueueFamilies(Render_Core::get().getDevice().getPhysicalDevice(), renderer->getSurface().get()); - uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() }; + std::uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() }; VkSwapchainCreateInfoKHR createInfo{}; createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; @@ -90,7 +90,7 @@ namespace mlx if(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities) != VK_SUCCESS) core::error::report(e_kind::fatal_error, "Vulkan : unable to retrieve surface capabilities"); - uint32_t formatCount = 0; + std::uint32_t formatCount = 0; vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr); if(formatCount != 0) @@ -99,7 +99,7 @@ namespace mlx vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data()); } - uint32_t presentModeCount; + std::uint32_t presentModeCount; vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr); if(presentModeCount != 0) @@ -119,13 +119,13 @@ namespace mlx VkExtent2D SwapChain::chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities) { - if(capabilities.currentExtent.width != std::numeric_limits::max()) + if(capabilities.currentExtent.width != std::numeric_limits::max()) return capabilities.currentExtent; int width, height; SDL_Vulkan_GetDrawableSize(_renderer->getWindow()->getNativeWindow(), &width, &height); - VkExtent2D actualExtent = { static_cast(width), static_cast(height) }; + VkExtent2D actualExtent = { static_cast(width), static_cast(height) }; actualExtent.width = std::clamp(actualExtent.width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width); actualExtent.height = std::clamp(actualExtent.height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height); diff --git a/src/renderer/swapchain/vk_swapchain.h b/src/renderer/swapchain/vk_swapchain.h index 5fd8827..998ae78 100644 --- a/src/renderer/swapchain/vk_swapchain.h +++ b/src/renderer/swapchain/vk_swapchain.h @@ -47,7 +47,7 @@ namespace mlx inline VkSwapchainKHR get() noexcept { return _swapChain; } inline VkSwapchainKHR operator()() noexcept { return _swapChain; } - inline size_t getImagesNumber() const noexcept { return _images.size(); } + inline std::size_t getImagesNumber() const noexcept { return _images.size(); } inline Image& getImage(std::size_t i) noexcept { return _images[i]; } inline SwapChainSupportDetails getSupport() noexcept { return _swapChainSupport; } inline VkExtent2D getExtent() noexcept { return _extent; } diff --git a/src/renderer/texts/font.cpp b/src/renderer/texts/font.cpp index d025e12..37f2d0a 100644 --- a/src/renderer/texts/font.cpp +++ b/src/renderer/texts/font.cpp @@ -24,7 +24,7 @@ namespace mlx _build_data = path; } - Font::Font(class Renderer& renderer, const std::string& name, const std::vector& ttf_data, float scale) : _name(name), _renderer(renderer), _scale(scale) + Font::Font(class Renderer& renderer, const std::string& name, const std::vector& ttf_data, float scale) : _name(name), _renderer(renderer), _scale(scale) { _build_data = ttf_data; } @@ -32,7 +32,7 @@ namespace mlx void Font::buildFont() { MLX_PROFILE_FUNCTION(); - std::vector file_bytes; + std::vector file_bytes; if(std::holds_alternative(_build_data)) { std::ifstream file(std::get(_build_data), std::ios::binary); @@ -48,14 +48,14 @@ namespace mlx file.close(); } - std::vector tmp_bitmap(RANGE * RANGE); - std::vector vulkan_bitmap(RANGE * RANGE * 4); + std::vector tmp_bitmap(RANGE * RANGE); + std::vector vulkan_bitmap(RANGE * RANGE * 4); stbtt_pack_context pc; stbtt_PackBegin(&pc, tmp_bitmap.data(), RANGE, RANGE, RANGE, 1, nullptr); if(std::holds_alternative(_build_data)) stbtt_PackFontRange(&pc, file_bytes.data(), 0, _scale, 32, 96, _cdata.data()); else - stbtt_PackFontRange(&pc, std::get>(_build_data).data(), 0, _scale, 32, 96, _cdata.data()); + stbtt_PackFontRange(&pc, std::get>(_build_data).data(), 0, _scale, 32, 96, _cdata.data()); stbtt_PackEnd(&pc); for(int i = 0, j = 0; i < RANGE * RANGE; i++, j += 4) { diff --git a/src/renderer/texts/font.h b/src/renderer/texts/font.h index 9e39cde..0c898a8 100644 --- a/src/renderer/texts/font.h +++ b/src/renderer/texts/font.h @@ -27,7 +27,7 @@ namespace mlx public: Font() = delete; Font(class Renderer& renderer, const std::filesystem::path& path, float scale); - Font(class Renderer& renderer, const std::string& name, const std::vector& ttf_data, float scale); + Font(class Renderer& renderer, const std::string& name, const std::vector& ttf_data, float scale); inline const std::string& getName() const { return _name; } inline float getScale() const noexcept { return _scale; } @@ -45,7 +45,7 @@ namespace mlx private: std::array _cdata; TextureAtlas _atlas; - std::variant> _build_data; + std::variant> _build_data; std::string _name; class Renderer& _renderer; float _scale = 0; diff --git a/src/renderer/texts/font_library.h b/src/renderer/texts/font_library.h index 9a1d4dc..3019ea1 100644 --- a/src/renderer/texts/font_library.h +++ b/src/renderer/texts/font_library.h @@ -24,7 +24,7 @@ namespace mlx { - using FontID = uint32_t; + using FontID = std::uint32_t; constexpr FontID nullfont = 0; class FontLibrary : public Singleton diff --git a/src/renderer/texts/text.cpp b/src/renderer/texts/text.cpp index b26c01c..f08eea9 100644 --- a/src/renderer/texts/text.cpp +++ b/src/renderer/texts/text.cpp @@ -16,7 +16,7 @@ namespace mlx { - void Text::init(std::string text, FontID font, std::vector vbo_data, std::vector ibo_data) + void Text::init(std::string text, FontID font, std::vector vbo_data, std::vector ibo_data) { MLX_PROFILE_FUNCTION(); _text = std::move(text); @@ -30,11 +30,11 @@ namespace mlx } for(int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) _vbo[i].create(sizeof(Vertex) * vbo_data.size(), static_cast(vbo_data.data()), debug_name.c_str()); - _ibo.create(sizeof(uint16_t) * ibo_data.size(), ibo_data.data(), debug_name.c_str()); + _ibo.create(sizeof(std::uint16_t) * ibo_data.size(), ibo_data.data(), debug_name.c_str()); #else for(int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) _vbo[i].create(sizeof(Vertex) * vbo_data.size(), static_cast(vbo_data.data()), nullptr); - _ibo.create(sizeof(uint16_t) * ibo_data.size(), ibo_data.data(), nullptr); + _ibo.create(sizeof(std::uint16_t) * ibo_data.size(), ibo_data.data(), nullptr); #endif } diff --git a/src/renderer/texts/text.h b/src/renderer/texts/text.h index 44bd7a1..8abaedc 100644 --- a/src/renderer/texts/text.h +++ b/src/renderer/texts/text.h @@ -27,11 +27,11 @@ namespace mlx public: Text() = default; - void init(std::string text, FontID font, std::vector vbo_data, std::vector ibo_data); + void init(std::string text, FontID font, std::vector vbo_data, std::vector ibo_data); void bind(class Renderer& renderer) noexcept; inline FontID getFontInUse() const noexcept { return _font; } void updateVertexData(int frame, std::vector vbo_data); - inline uint32_t getIBOsize() noexcept { return _ibo.getSize(); } + inline std::uint32_t getIBOsize() noexcept { return _ibo.getSize(); } inline const std::string& getText() const { return _text; } void destroy() noexcept; diff --git a/src/renderer/texts/text_descriptor.cpp b/src/renderer/texts/text_descriptor.cpp index 4db185a..752e736 100644 --- a/src/renderer/texts/text_descriptor.cpp +++ b/src/renderer/texts/text_descriptor.cpp @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/01/11 00:23:11 by maldavid #+# #+# */ -/* Updated: 2024/01/18 09:44:54 by maldavid ### ########.fr */ +/* Updated: 2024/02/25 07:58:21 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ @@ -30,14 +30,14 @@ constexpr const int RANGE = 1024; namespace mlx { - TextDrawDescriptor::TextDrawDescriptor(std::string text, uint32_t _color, int _x, int _y) : color(_color), x(_x), y(_y), _text(std::move(text)) + TextDrawDescriptor::TextDrawDescriptor(std::string text, std::uint32_t _color, int _x, int _y) : color(_color), x(_x), y(_y), _text(std::move(text)) {} void TextDrawDescriptor::init(FontID font) noexcept { MLX_PROFILE_FUNCTION(); std::vector vertexData; - std::vector indexData; + std::vector indexData; float stb_x = 0.0f; float stb_y = 0.0f; diff --git a/src/renderer/texts/text_descriptor.h b/src/renderer/texts/text_descriptor.h index bc8d239..27a89cd 100644 --- a/src/renderer/texts/text_descriptor.h +++ b/src/renderer/texts/text_descriptor.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/01/11 00:13:34 by maldavid #+# #+# */ -/* Updated: 2024/01/18 09:40:06 by maldavid ### ########.fr */ +/* Updated: 2024/02/25 07:58:13 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ @@ -30,12 +30,12 @@ namespace mlx public: TextID id; - uint32_t color; + std::uint32_t color; int x; int y; public: - TextDrawDescriptor(std::string text, uint32_t _color, int _x, int _y); + TextDrawDescriptor(std::string text, std::uint32_t _color, int _x, int _y); void init(FontID font) noexcept; bool operator==(const TextDrawDescriptor& rhs) const { return _text == rhs._text && x == rhs.x && y == rhs.y && color == rhs.color; } diff --git a/src/renderer/texts/text_library.cpp b/src/renderer/texts/text_library.cpp index 4a61b38..ae52ba4 100644 --- a/src/renderer/texts/text_library.cpp +++ b/src/renderer/texts/text_library.cpp @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/04/10 11:59:57 by maldavid #+# #+# */ -/* Updated: 2024/01/18 08:02:31 by maldavid ### ########.fr */ +/* Updated: 2024/02/24 21:38:11 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ @@ -16,6 +16,7 @@ #include #include #include +#include namespace mlx { @@ -49,6 +50,7 @@ namespace mlx core::error::report(e_kind::warning, "Text Library : trying to remove a text with an unkown or invalid ID '%d'", id); return; } + std::cout << _cache[id]->getText() << std::endl; _cache[id]->destroy(); _invalid_ids.push_back(id); } diff --git a/src/renderer/texts/text_library.h b/src/renderer/texts/text_library.h index 9bdef36..d7dab98 100644 --- a/src/renderer/texts/text_library.h +++ b/src/renderer/texts/text_library.h @@ -26,7 +26,7 @@ namespace mlx { - using TextID = uint32_t; + using TextID = std::uint32_t; constexpr TextID nulltext = 0; class TextLibrary : public Singleton diff --git a/src/renderer/texts/text_manager.cpp b/src/renderer/texts/text_manager.cpp index 81dffd7..3588c78 100644 --- a/src/renderer/texts/text_manager.cpp +++ b/src/renderer/texts/text_manager.cpp @@ -6,10 +6,11 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/04/06 16:41:13 by maldavid #+# #+# */ -/* Updated: 2024/01/18 09:45:24 by maldavid ### ########.fr */ +/* Updated: 2024/02/24 21:39:12 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ +#include #include #include #include @@ -38,7 +39,7 @@ namespace mlx _font_in_use = FontLibrary::get().addFontToLibrary(font); } - std::pair TextManager::registerText(int x, int y, uint32_t color, std::string str) + std::pair TextManager::registerText(int x, int y, std::uint32_t color, std::string str) { MLX_PROFILE_FUNCTION(); auto res = _text_descriptors.emplace(std::move(str), color, x, y); @@ -52,6 +53,7 @@ namespace mlx if(_font_in_use != text_ptr->getFontInUse()) { // TODO : update text vertex buffers rather than destroying it and recreating it + std::cout << "test" << std::endl; TextLibrary::get().removeTextFromLibrary(res.first->id); const_cast(*res.first).init(_font_in_use); } diff --git a/src/renderer/texts/text_manager.h b/src/renderer/texts/text_manager.h index 8198b66..4a3c998 100644 --- a/src/renderer/texts/text_manager.h +++ b/src/renderer/texts/text_manager.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/04/06 16:24:11 by maldavid #+# #+# */ -/* Updated: 2024/01/18 13:52:01 by maldavid ### ########.fr */ +/* Updated: 2024/02/25 07:58:36 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ @@ -34,8 +34,8 @@ namespace mlx TextManager() = default; void init(Renderer& renderer) noexcept; - std::pair registerText(int x, int y, uint32_t color, std::string str); - inline void clear() { _text_descriptors.clear(); TextLibrary::get().clearLibrary(); } + std::pair registerText(int x, int y, std::uint32_t color, std::string str); + inline void clear() { _text_descriptors.clear(); } void loadFont(Renderer& renderer, const std::filesystem::path& filepath, float scale); void destroy() noexcept; diff --git a/src/utils/icon_mlx.h b/src/utils/icon_mlx.h index a5450fb..04f0029 100644 --- a/src/utils/icon_mlx.h +++ b/src/utils/icon_mlx.h @@ -19,7 +19,7 @@ constexpr const int logo_mlx_height = 125; constexpr const int logo_mlx_width = 125; constexpr const int logo_mlx_size = logo_mlx_height * logo_mlx_width * 4; -inline static uint8_t logo_mlx[logo_mlx_size] = { +inline static std::uint8_t logo_mlx[logo_mlx_size] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, From 7b64359f3ef957a57e463d6c8669bb85f8ab5a08 Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Sun, 25 Feb 2024 09:02:57 +0100 Subject: [PATCH 6/6] fixing issue with text destruction --- src/renderer/texts/text.cpp | 17 ++++++++++++++++- src/renderer/texts/text.h | 5 +++-- src/renderer/texts/text_manager.cpp | 3 +-- 3 files changed, 20 insertions(+), 5 deletions(-) diff --git a/src/renderer/texts/text.cpp b/src/renderer/texts/text.cpp index f08eea9..dbbd264 100644 --- a/src/renderer/texts/text.cpp +++ b/src/renderer/texts/text.cpp @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/01/11 00:11:56 by maldavid #+# #+# */ -/* Updated: 2024/01/18 13:56:50 by maldavid ### ########.fr */ +/* Updated: 2024/02/25 09:01:46 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ @@ -19,6 +19,8 @@ namespace mlx void Text::init(std::string text, FontID font, std::vector vbo_data, std::vector ibo_data) { MLX_PROFILE_FUNCTION(); + if(_is_init) + return; _text = std::move(text); _font = font; #ifdef DEBUG @@ -36,11 +38,14 @@ namespace mlx _vbo[i].create(sizeof(Vertex) * vbo_data.size(), static_cast(vbo_data.data()), nullptr); _ibo.create(sizeof(std::uint16_t) * ibo_data.size(), ibo_data.data(), nullptr); #endif + _is_init = true; } void Text::bind(Renderer& renderer) noexcept { MLX_PROFILE_FUNCTION(); + if(!_is_init) + return; _vbo[renderer.getActiveImageIndex()].bind(renderer); _ibo.bind(renderer); } @@ -48,14 +53,24 @@ namespace mlx void Text::updateVertexData(int frame, std::vector vbo_data) { MLX_PROFILE_FUNCTION(); + if(!_is_init) + return; _vbo[frame].setData(sizeof(Vertex) * vbo_data.size(), static_cast(vbo_data.data())); } void Text::destroy() noexcept { MLX_PROFILE_FUNCTION(); + if(!_is_init) + return; for(int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) _vbo[i].destroy(); _ibo.destroy(); + _is_init = false; + } + + Text::~Text() + { + destroy(); } } diff --git a/src/renderer/texts/text.h b/src/renderer/texts/text.h index 8abaedc..88c588f 100644 --- a/src/renderer/texts/text.h +++ b/src/renderer/texts/text.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/01/11 00:09:04 by maldavid #+# #+# */ -/* Updated: 2024/01/18 09:37:42 by maldavid ### ########.fr */ +/* Updated: 2024/02/25 09:00:26 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ @@ -35,13 +35,14 @@ namespace mlx inline const std::string& getText() const { return _text; } void destroy() noexcept; - ~Text() = default; + ~Text(); private: std::array _vbo; C_IBO _ibo; std::string _text; FontID _font = nullfont; + bool _is_init = false; }; } diff --git a/src/renderer/texts/text_manager.cpp b/src/renderer/texts/text_manager.cpp index 3588c78..2a08340 100644 --- a/src/renderer/texts/text_manager.cpp +++ b/src/renderer/texts/text_manager.cpp @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/04/06 16:41:13 by maldavid #+# #+# */ -/* Updated: 2024/02/24 21:39:12 by maldavid ### ########.fr */ +/* Updated: 2024/02/25 08:17:09 by maldavid ### ########.fr */ /* */ /* ************************************************************************** */ @@ -53,7 +53,6 @@ namespace mlx if(_font_in_use != text_ptr->getFontInUse()) { // TODO : update text vertex buffers rather than destroying it and recreating it - std::cout << "test" << std::endl; TextLibrary::get().removeTextFromLibrary(res.first->id); const_cast(*res.first).init(_font_in_use); }