From 724c3ca76b694e737a37cf2fd5df2af1425814ce Mon Sep 17 00:00:00 2001 From: Jon Leech <4693344+oddhack@users.noreply.github.com> Date: Mon, 20 Dec 2021 04:19:40 -0800 Subject: [PATCH] Update for Vulkan-Docs 1.2.203 --- include/vk_video/vulkan_video_codec_h264std.h | 324 +- .../vk_video/vulkan_video_codec_h264std_decode.h | 113 +- .../vk_video/vulkan_video_codec_h264std_encode.h | 109 +- include/vk_video/vulkan_video_codec_h265std.h | 539 +- .../vk_video/vulkan_video_codec_h265std_decode.h | 66 +- .../vk_video/vulkan_video_codec_h265std_encode.h | 165 +- include/vk_video/vulkan_video_codecs_common.h | 18 +- include/vulkan/vulkan.hpp | 80 +- include/vulkan/vulkan_beta.h | 13 +- include/vulkan/vulkan_core.h | 51 +- include/vulkan/vulkan_enums.hpp | 96 +- include/vulkan/vulkan_handles.hpp | 489 +- include/vulkan/vulkan_raii.hpp | 6 +- include/vulkan/vulkan_structs.hpp | 36060 ++++++++----------- registry/generator.py | 6 +- registry/genvk.py | 77 + registry/reg.py | 117 +- registry/validusage.json | 438 +- registry/vk.xml | 180 +- 19 files changed, 16581 insertions(+), 22366 deletions(-) diff --git a/include/vk_video/vulkan_video_codec_h264std.h b/include/vk_video/vulkan_video_codec_h264std.h index 3338fe1..27e4438 100644 --- a/include/vk_video/vulkan_video_codec_h264std.h +++ b/include/vk_video/vulkan_video_codec_h264std.h @@ -1,49 +1,53 @@ +#ifndef VULKAN_VIDEO_CODEC_H264STD_H_ +#define VULKAN_VIDEO_CODEC_H264STD_H_ 1 + /* -** Copyright (c) 2019-2021 The Khronos Group Inc. +** Copyright 2015-2021 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ -#ifndef VULKAN_VIDEO_CODEC_H264STD_H_ -#define VULKAN_VIDEO_CODEC_H264STD_H_ 1 +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + #ifdef __cplusplus extern "C" { #endif -#include "vk_video/vulkan_video_codecs_common.h" + +#define vulkan_video_codec_h264std 1 +#include // Vulkan 0.9 provisional Vulkan video H.264 encode and decode std specification version number #define VK_STD_VULKAN_VIDEO_CODEC_H264_API_VERSION_0_9_5 VK_MAKE_VIDEO_STD_VERSION(0, 9, 5) // Patch version should always be set to 0 -// Format must be in the form XX.XX where the first two digits are the major and the second two, the minor. -#define VK_STD_VULKAN_VIDEO_CODEC_H264_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_API_VERSION_0_9_5 -#define VK_STD_VULKAN_VIDEO_CODEC_H264_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264" - -// ************************************************* -// Video H.264 common definitions: -// ************************************************* - -#define STD_VIDEO_H264_CPB_CNT_LIST_SIZE 32 +#define STD_VIDEO_H264_CPB_CNT_LIST_SIZE 32 #define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6 #define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16 #define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS 2 #define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS 64 +#define VK_STD_VULKAN_VIDEO_CODEC_H264_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_API_VERSION_0_9_5 +#define VK_STD_VULKAN_VIDEO_CODEC_H264_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264" typedef enum StdVideoH264ChromaFormatIdc { - STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME = 0, - STD_VIDEO_H264_CHROMA_FORMAT_IDC_420 = 1, - STD_VIDEO_H264_CHROMA_FORMAT_IDC_422 = 2, - STD_VIDEO_H264_CHROMA_FORMAT_IDC_444 = 3, - STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF + STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME = 0, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_420 = 1, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_422 = 2, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_444 = 3, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_MAX_ENUM = 0x7FFFFFFF } StdVideoH264ChromaFormatIdc; typedef enum StdVideoH264ProfileIdc { - STD_VIDEO_H264_PROFILE_IDC_BASELINE = 66, /* Only constrained baseline is supported */ - STD_VIDEO_H264_PROFILE_IDC_MAIN = 77, - STD_VIDEO_H264_PROFILE_IDC_HIGH = 100, - STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE = 244, - STD_VIDEO_H264_PROFILE_IDC_INVALID = 0x7FFFFFFF + STD_VIDEO_H264_PROFILE_IDC_BASELINE = 66, + STD_VIDEO_H264_PROFILE_IDC_MAIN = 77, + STD_VIDEO_H264_PROFILE_IDC_HIGH = 100, + STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE = 244, + STD_VIDEO_H264_PROFILE_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF } StdVideoH264ProfileIdc; typedef enum StdVideoH264Level { @@ -66,14 +70,16 @@ typedef enum StdVideoH264Level { STD_VIDEO_H264_LEVEL_6_0 = 16, STD_VIDEO_H264_LEVEL_6_1 = 17, STD_VIDEO_H264_LEVEL_6_2 = 18, - STD_VIDEO_H264_LEVEL_INVALID = 0x7FFFFFFF + STD_VIDEO_H264_LEVEL_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_LEVEL_MAX_ENUM = 0x7FFFFFFF } StdVideoH264Level; typedef enum StdVideoH264PocType { STD_VIDEO_H264_POC_TYPE_0 = 0, STD_VIDEO_H264_POC_TYPE_1 = 1, STD_VIDEO_H264_POC_TYPE_2 = 2, - STD_VIDEO_H264_POC_TYPE_INVALID = 0x7FFFFFFF + STD_VIDEO_H264_POC_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_POC_TYPE_MAX_ENUM = 0x7FFFFFFF } StdVideoH264PocType; typedef enum StdVideoH264AspectRatioIdc { @@ -95,14 +101,16 @@ typedef enum StdVideoH264AspectRatioIdc { STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2 = 15, STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1 = 16, STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR = 255, - STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF + STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_ASPECT_RATIO_IDC_MAX_ENUM = 0x7FFFFFFF } StdVideoH264AspectRatioIdc; typedef enum StdVideoH264WeightedBipredIdc { - STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT = 0, + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT = 0, STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT = 1, STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT = 2, - STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID = 0x7FFFFFFF + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_MAX_ENUM = 0x7FFFFFFF } StdVideoH264WeightedBipredIdc; typedef enum StdVideoH264ModificationOfPicNumsIdc { @@ -110,7 +118,8 @@ typedef enum StdVideoH264ModificationOfPicNumsIdc { STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD = 1, STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM = 2, STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END = 3, - STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID = 0x7FFFFFFF + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_MAX_ENUM = 0x7FFFFFFF } StdVideoH264ModificationOfPicNumsIdc; typedef enum StdVideoH264MemMgmtControlOp { @@ -121,40 +130,41 @@ typedef enum StdVideoH264MemMgmtControlOp { STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX = 4, STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL = 5, STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM = 6, - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID = 0x7FFFFFFF + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MAX_ENUM = 0x7FFFFFFF } StdVideoH264MemMgmtControlOp; typedef enum StdVideoH264CabacInitIdc { STD_VIDEO_H264_CABAC_INIT_IDC_0 = 0, STD_VIDEO_H264_CABAC_INIT_IDC_1 = 1, STD_VIDEO_H264_CABAC_INIT_IDC_2 = 2, - STD_VIDEO_H264_CABAC_INIT_IDC_INVALID = 0x7FFFFFFF + STD_VIDEO_H264_CABAC_INIT_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_CABAC_INIT_IDC_MAX_ENUM = 0x7FFFFFFF } StdVideoH264CabacInitIdc; typedef enum StdVideoH264DisableDeblockingFilterIdc { STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED = 0, STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED = 1, STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL = 2, - STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID = 0x7FFFFFFF + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_MAX_ENUM = 0x7FFFFFFF } StdVideoH264DisableDeblockingFilterIdc; typedef enum StdVideoH264SliceType { - STD_VIDEO_H264_SLICE_TYPE_P = 0, - STD_VIDEO_H264_SLICE_TYPE_B = 1, - STD_VIDEO_H264_SLICE_TYPE_I = 2, - // reserved STD_VIDEO_H264_SLICE_TYPE_SP = 3, - // reserved STD_VIDEO_H264_SLICE_TYPE_SI = 4, - STD_VIDEO_H264_SLICE_TYPE_INVALID = 0x7FFFFFFF + STD_VIDEO_H264_SLICE_TYPE_P = 0, + STD_VIDEO_H264_SLICE_TYPE_B = 1, + STD_VIDEO_H264_SLICE_TYPE_I = 2, + STD_VIDEO_H264_SLICE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_SLICE_TYPE_MAX_ENUM = 0x7FFFFFFF } StdVideoH264SliceType; typedef enum StdVideoH264PictureType { - STD_VIDEO_H264_PICTURE_TYPE_P = 0, - STD_VIDEO_H264_PICTURE_TYPE_B = 1, - STD_VIDEO_H264_PICTURE_TYPE_I = 2, - // reserved STD_VIDEO_H264_PICTURE_TYPE_SP = 3, - // reserved STD_VIDEO_H264_PICTURE_TYPE_SI = 4, + STD_VIDEO_H264_PICTURE_TYPE_P = 0, + STD_VIDEO_H264_PICTURE_TYPE_B = 1, + STD_VIDEO_H264_PICTURE_TYPE_I = 2, STD_VIDEO_H264_PICTURE_TYPE_IDR = 5, - STD_VIDEO_H264_PICTURE_TYPE_INVALID = 0x7FFFFFFF + STD_VIDEO_H264_PICTURE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_PICTURE_TYPE_MAX_ENUM = 0x7FFFFFFF } StdVideoH264PictureType; typedef enum StdVideoH264NonVclNaluType { @@ -165,148 +175,134 @@ typedef enum StdVideoH264NonVclNaluType { STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE = 4, STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM = 5, STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED = 6, - STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID = 0x7FFFFFFF + STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_MAX_ENUM = 0x7FFFFFFF } StdVideoH264NonVclNaluType; - typedef struct StdVideoH264SpsVuiFlags { - uint32_t aspect_ratio_info_present_flag : 1; - uint32_t overscan_info_present_flag : 1; - uint32_t overscan_appropriate_flag : 1; - uint32_t video_signal_type_present_flag : 1; - uint32_t video_full_range_flag : 1; - uint32_t color_description_present_flag : 1; - uint32_t chroma_loc_info_present_flag : 1; - uint32_t timing_info_present_flag : 1; - uint32_t fixed_frame_rate_flag : 1; - uint32_t bitstream_restriction_flag : 1; - uint32_t nal_hrd_parameters_present_flag : 1; - uint32_t vcl_hrd_parameters_present_flag : 1; + uint32_t aspect_ratio_info_present_flag : 1; + uint32_t overscan_info_present_flag : 1; + uint32_t overscan_appropriate_flag : 1; + uint32_t video_signal_type_present_flag : 1; + uint32_t video_full_range_flag : 1; + uint32_t color_description_present_flag : 1; + uint32_t chroma_loc_info_present_flag : 1; + uint32_t timing_info_present_flag : 1; + uint32_t fixed_frame_rate_flag : 1; + uint32_t bitstream_restriction_flag : 1; + uint32_t nal_hrd_parameters_present_flag : 1; + uint32_t vcl_hrd_parameters_present_flag : 1; } StdVideoH264SpsVuiFlags; -typedef struct StdVideoH264HrdParameters { // hrd_parameters - uint8_t cpb_cnt_minus1; - uint8_t bit_rate_scale; - uint8_t cpb_size_scale; - uint32_t bit_rate_value_minus1[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; // cpb_cnt_minus1 number of valid elements - uint32_t cpb_size_value_minus1[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; // cpb_cnt_minus1 number of valid elements - uint8_t cbr_flag[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; // cpb_cnt_minus1 number of valid elements - uint32_t initial_cpb_removal_delay_length_minus1; - uint32_t cpb_removal_delay_length_minus1; - uint32_t dpb_output_delay_length_minus1; - uint32_t time_offset_length; +typedef struct StdVideoH264HrdParameters { + uint8_t cpb_cnt_minus1; + uint8_t bit_rate_scale; + uint8_t cpb_size_scale; + uint32_t bit_rate_value_minus1[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; + uint32_t cpb_size_value_minus1[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; + uint8_t cbr_flag[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; + uint32_t initial_cpb_removal_delay_length_minus1; + uint32_t cpb_removal_delay_length_minus1; + uint32_t dpb_output_delay_length_minus1; + uint32_t time_offset_length; } StdVideoH264HrdParameters; typedef struct StdVideoH264SequenceParameterSetVui { - StdVideoH264AspectRatioIdc aspect_ratio_idc; - uint16_t sar_width; - uint16_t sar_height; - uint8_t video_format; - uint8_t color_primaries; - uint8_t transfer_characteristics; - uint8_t matrix_coefficients; - uint32_t num_units_in_tick; - uint32_t time_scale; - StdVideoH264HrdParameters* pHrdParameters; // must be a valid ptr to hrd_parameters, if nal_hrd_parameters_present_flag or vcl_hrd_parameters_present_flag are set - uint8_t max_num_reorder_frames; - uint8_t max_dec_frame_buffering; - StdVideoH264SpsVuiFlags flags; + StdVideoH264AspectRatioIdc aspect_ratio_idc; + uint16_t sar_width; + uint16_t sar_height; + uint8_t video_format; + uint8_t color_primaries; + uint8_t transfer_characteristics; + uint8_t matrix_coefficients; + uint32_t num_units_in_tick; + uint32_t time_scale; + StdVideoH264HrdParameters* pHrdParameters; + uint8_t max_num_reorder_frames; + uint8_t max_dec_frame_buffering; + StdVideoH264SpsVuiFlags flags; } StdVideoH264SequenceParameterSetVui; typedef struct StdVideoH264SpsFlags { - uint32_t constraint_set0_flag : 1; - uint32_t constraint_set1_flag : 1; - uint32_t constraint_set2_flag : 1; - uint32_t constraint_set3_flag : 1; - uint32_t constraint_set4_flag : 1; - uint32_t constraint_set5_flag : 1; - uint32_t direct_8x8_inference_flag : 1; - uint32_t mb_adaptive_frame_field_flag : 1; - uint32_t frame_mbs_only_flag : 1; - uint32_t delta_pic_order_always_zero_flag : 1; - uint32_t separate_colour_plane_flag : 1; - uint32_t gaps_in_frame_num_value_allowed_flag : 1; - uint32_t qpprime_y_zero_transform_bypass_flag : 1; - uint32_t frame_cropping_flag : 1; - uint32_t seq_scaling_matrix_present_flag : 1; - uint32_t vui_parameters_present_flag : 1; + uint32_t constraint_set0_flag : 1; + uint32_t constraint_set1_flag : 1; + uint32_t constraint_set2_flag : 1; + uint32_t constraint_set3_flag : 1; + uint32_t constraint_set4_flag : 1; + uint32_t constraint_set5_flag : 1; + uint32_t direct_8x8_inference_flag : 1; + uint32_t mb_adaptive_frame_field_flag : 1; + uint32_t frame_mbs_only_flag : 1; + uint32_t delta_pic_order_always_zero_flag : 1; + uint32_t separate_colour_plane_flag : 1; + uint32_t gaps_in_frame_num_value_allowed_flag : 1; + uint32_t qpprime_y_zero_transform_bypass_flag : 1; + uint32_t frame_cropping_flag : 1; + uint32_t seq_scaling_matrix_present_flag : 1; + uint32_t vui_parameters_present_flag : 1; } StdVideoH264SpsFlags; -typedef struct StdVideoH264ScalingLists -{ - // scaling_list_present_mask has one bit for each - // seq_scaling_list_present_flag[i] for SPS OR - // pic_scaling_list_present_flag[i] for PPS, - // bit 0 - 5 are for each entry of ScalingList4x4 - // bit 6 - 7 are for each entry plus 6 for ScalingList8x8 - uint8_t scaling_list_present_mask; - // use_default_scaling_matrix_mask has one bit for each - // UseDefaultScalingMatrix4x4Flag[ i ] and - // UseDefaultScalingMatrix8x8Flag[ i - 6 ] for SPS OR PPS - // bit 0 - 5 are for each entry of ScalingList4x4 - // bit 6 - 7 are for each entry plus 6 for ScalingList8x8 - uint8_t use_default_scaling_matrix_mask; - uint8_t ScalingList4x4[STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS]; - uint8_t ScalingList8x8[STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS]; +typedef struct StdVideoH264ScalingLists { + uint8_t scaling_list_present_mask; + uint8_t use_default_scaling_matrix_mask; + uint8_t ScalingList4x4[STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS]; + uint8_t ScalingList8x8[STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS]; } StdVideoH264ScalingLists; -typedef struct StdVideoH264SequenceParameterSet -{ - StdVideoH264ProfileIdc profile_idc; - StdVideoH264Level level_idc; - uint8_t seq_parameter_set_id; - StdVideoH264ChromaFormatIdc chroma_format_idc; - uint8_t bit_depth_luma_minus8; - uint8_t bit_depth_chroma_minus8; - uint8_t log2_max_frame_num_minus4; - StdVideoH264PocType pic_order_cnt_type; - uint8_t log2_max_pic_order_cnt_lsb_minus4; - int32_t offset_for_non_ref_pic; - int32_t offset_for_top_to_bottom_field; - uint8_t num_ref_frames_in_pic_order_cnt_cycle; - uint8_t max_num_ref_frames; - uint32_t pic_width_in_mbs_minus1; - uint32_t pic_height_in_map_units_minus1; - uint32_t frame_crop_left_offset; - uint32_t frame_crop_right_offset; - uint32_t frame_crop_top_offset; - uint32_t frame_crop_bottom_offset; - StdVideoH264SpsFlags flags; - // pOffsetForRefFrame is a pointer representing the offset_for_ref_frame array with num_ref_frames_in_pic_order_cnt_cycle number of elements - // If pOffsetForRefFrame has nullptr value, then num_ref_frames_in_pic_order_cnt_cycle must also be "0". - int32_t* pOffsetForRefFrame; - StdVideoH264ScalingLists* pScalingLists; // Must be a valid pointer if seq_scaling_matrix_present_flag is set - StdVideoH264SequenceParameterSetVui* pSequenceParameterSetVui; // Must be a valid pointer if StdVideoH264SpsFlags:vui_parameters_present_flag is set +typedef struct StdVideoH264SequenceParameterSet { + StdVideoH264ProfileIdc profile_idc; + StdVideoH264Level level_idc; + uint8_t seq_parameter_set_id; + StdVideoH264ChromaFormatIdc chroma_format_idc; + uint8_t bit_depth_luma_minus8; + uint8_t bit_depth_chroma_minus8; + uint8_t log2_max_frame_num_minus4; + StdVideoH264PocType pic_order_cnt_type; + uint8_t log2_max_pic_order_cnt_lsb_minus4; + int32_t offset_for_non_ref_pic; + int32_t offset_for_top_to_bottom_field; + uint8_t num_ref_frames_in_pic_order_cnt_cycle; + uint8_t max_num_ref_frames; + uint32_t pic_width_in_mbs_minus1; + uint32_t pic_height_in_map_units_minus1; + uint32_t frame_crop_left_offset; + uint32_t frame_crop_right_offset; + uint32_t frame_crop_top_offset; + uint32_t frame_crop_bottom_offset; + StdVideoH264SpsFlags flags; + int32_t* pOffsetForRefFrame; + StdVideoH264ScalingLists* pScalingLists; + StdVideoH264SequenceParameterSetVui* pSequenceParameterSetVui; } StdVideoH264SequenceParameterSet; typedef struct StdVideoH264PpsFlags { - uint32_t transform_8x8_mode_flag : 1; - uint32_t redundant_pic_cnt_present_flag : 1; - uint32_t constrained_intra_pred_flag : 1; - uint32_t deblocking_filter_control_present_flag : 1; - uint32_t weighted_bipred_idc_flag : 1; - uint32_t weighted_pred_flag : 1; - uint32_t pic_order_present_flag : 1; - uint32_t entropy_coding_mode_flag : 1; - uint32_t pic_scaling_matrix_present_flag : 1; + uint32_t transform_8x8_mode_flag : 1; + uint32_t redundant_pic_cnt_present_flag : 1; + uint32_t constrained_intra_pred_flag : 1; + uint32_t deblocking_filter_control_present_flag : 1; + uint32_t weighted_bipred_idc_flag : 1; + uint32_t weighted_pred_flag : 1; + uint32_t pic_order_present_flag : 1; + uint32_t entropy_coding_mode_flag : 1; + uint32_t pic_scaling_matrix_present_flag : 1; } StdVideoH264PpsFlags; -typedef struct StdVideoH264PictureParameterSet -{ - uint8_t seq_parameter_set_id; - uint8_t pic_parameter_set_id; - uint8_t num_ref_idx_l0_default_active_minus1; - uint8_t num_ref_idx_l1_default_active_minus1; - StdVideoH264WeightedBipredIdc weighted_bipred_idc; - int8_t pic_init_qp_minus26; - int8_t pic_init_qs_minus26; - int8_t chroma_qp_index_offset; - int8_t second_chroma_qp_index_offset; - StdVideoH264PpsFlags flags; - StdVideoH264ScalingLists* pScalingLists; // Must be a valid pointer if StdVideoH264PpsFlags::pic_scaling_matrix_present_flag is set. +typedef struct StdVideoH264PictureParameterSet { + uint8_t seq_parameter_set_id; + uint8_t pic_parameter_set_id; + uint8_t num_ref_idx_l0_default_active_minus1; + uint8_t num_ref_idx_l1_default_active_minus1; + StdVideoH264WeightedBipredIdc weighted_bipred_idc; + int8_t pic_init_qp_minus26; + int8_t pic_init_qs_minus26; + int8_t chroma_qp_index_offset; + int8_t second_chroma_qp_index_offset; + StdVideoH264PpsFlags flags; + StdVideoH264ScalingLists* pScalingLists; } StdVideoH264PictureParameterSet; + #ifdef __cplusplus } #endif -#endif // VULKAN_VIDEO_CODEC_H264STD_H_ +#endif diff --git a/include/vk_video/vulkan_video_codec_h264std_decode.h b/include/vk_video/vulkan_video_codec_h264std_decode.h index cb0d1df..dda6009 100644 --- a/include/vk_video/vulkan_video_codec_h264std_decode.h +++ b/include/vk_video/vulkan_video_codec_h264std_decode.h @@ -1,92 +1,93 @@ +#ifndef VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ +#define VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ 1 + /* -** Copyright (c) 2019-2020 The Khronos Group Inc. +** Copyright 2015-2021 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ -#ifndef VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ -#define VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ 1 +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + #ifdef __cplusplus extern "C" { #endif -#include "vk_video/vulkan_video_codec_h264std.h" -// ************************************************* -// Video H.264 Decode related parameters: -// ************************************************* +#define vulkan_video_codec_h264std_decode 1 +#define STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE 2 #define STD_VIDEO_DECODE_H264_MVC_REF_LIST_SIZE 15 typedef enum StdVideoDecodeH264FieldOrderCount { - STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP = 0, - STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM = 1, - STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE = 2, - STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID = 0x7FFFFFFF -} StdVideoDecodeH264FieldOrderCnt; - + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP = 0, + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM = 1, + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID = 0x7FFFFFFF, + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_MAX_ENUM = 0x7FFFFFFF +} StdVideoDecodeH264FieldOrderCount; typedef struct StdVideoDecodeH264PictureInfoFlags { - uint32_t field_pic_flag : 1; // Is field picture - uint32_t is_intra : 1; // Is intra picture - uint32_t IdrPicFlag : 1; // instantaneous decoding refresh (IDR) picture - uint32_t bottom_field_flag : 1; // bottom (true) or top (false) field if field_pic_flag is set. - uint32_t is_reference : 1; // This only applies to picture info, and not to the DPB lists. - uint32_t complementary_field_pair : 1; // complementary field pair, complementary non-reference field pair, complementary reference field pair + uint32_t field_pic_flag : 1; + uint32_t is_intra : 1; + uint32_t IdrPicFlag : 1; + uint32_t bottom_field_flag : 1; + uint32_t is_reference : 1; + uint32_t complementary_field_pair : 1; } StdVideoDecodeH264PictureInfoFlags; typedef struct StdVideoDecodeH264PictureInfo { - uint8_t seq_parameter_set_id; // Selecting SPS from the Picture Parameters - uint8_t pic_parameter_set_id; // Selecting PPS from the Picture Parameters and the SPS - uint16_t reserved; // for structure members 32-bit packing/alignment - uint16_t frame_num; // 7.4.3 Slice header semantics - uint16_t idr_pic_id; // 7.4.3 Slice header semantics - // PicOrderCnt is based on TopFieldOrderCnt and BottomFieldOrderCnt. See 8.2.1 Decoding process for picture order count type 0 - 2 - int32_t PicOrderCnt[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]; // TopFieldOrderCnt and BottomFieldOrderCnt fields. - StdVideoDecodeH264PictureInfoFlags flags; + uint8_t seq_parameter_set_id; + uint8_t pic_parameter_set_id; + uint16_t reserved; + uint16_t frame_num; + uint16_t idr_pic_id; + int32_t PicOrderCnt[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]; + StdVideoDecodeH264PictureInfoFlags flags; } StdVideoDecodeH264PictureInfo; typedef struct StdVideoDecodeH264ReferenceInfoFlags { - uint32_t top_field_flag : 1; // Reference is used for top field reference. - uint32_t bottom_field_flag : 1; // Reference is used for bottom field reference. - uint32_t is_long_term : 1; // this is a long term reference - uint32_t is_non_existing : 1; // Must be handled in accordance with 8.2.5.2: Decoding process for gaps in frame_num + uint32_t top_field_flag : 1; + uint32_t bottom_field_flag : 1; + uint32_t is_long_term : 1; + uint32_t is_non_existing : 1; } StdVideoDecodeH264ReferenceInfoFlags; typedef struct StdVideoDecodeH264ReferenceInfo { - // FrameNum = is_long_term ? long_term_frame_idx : frame_num - uint16_t FrameNum; // 7.4.3.3 Decoded reference picture marking semantics - uint16_t reserved; // for structure members 32-bit packing/alignment - int32_t PicOrderCnt[2]; // TopFieldOrderCnt and BottomFieldOrderCnt fields. - StdVideoDecodeH264ReferenceInfoFlags flags; + uint16_t FrameNum; + uint16_t reserved; + int32_t PicOrderCnt[2]; + StdVideoDecodeH264ReferenceInfoFlags flags; } StdVideoDecodeH264ReferenceInfo; typedef struct StdVideoDecodeH264MvcElementFlags { - uint32_t non_idr : 1; - uint32_t anchor_pic : 1; - uint32_t inter_view : 1; + uint32_t non_idr : 1; + uint32_t anchor_pic : 1; + uint32_t inter_view : 1; } StdVideoDecodeH264MvcElementFlags; typedef struct StdVideoDecodeH264MvcElement { - StdVideoDecodeH264MvcElementFlags flags; - uint16_t viewOrderIndex; - uint16_t viewId; - uint16_t temporalId; // move out? - uint16_t priorityId; // move out? - uint16_t numOfAnchorRefsInL0; - uint16_t viewIdOfAnchorRefsInL0[STD_VIDEO_DECODE_H264_MVC_REF_LIST_SIZE]; - uint16_t numOfAnchorRefsInL1; - uint16_t viewIdOfAnchorRefsInL1[STD_VIDEO_DECODE_H264_MVC_REF_LIST_SIZE]; - uint16_t numOfNonAnchorRefsInL0; - uint16_t viewIdOfNonAnchorRefsInL0[STD_VIDEO_DECODE_H264_MVC_REF_LIST_SIZE]; - uint16_t numOfNonAnchorRefsInL1; - uint16_t viewIdOfNonAnchorRefsInL1[STD_VIDEO_DECODE_H264_MVC_REF_LIST_SIZE]; + StdVideoDecodeH264MvcElementFlags flags; + uint16_t viewOrderIndex; + uint16_t viewId; + uint16_t temporalId; + uint16_t priorityId; + uint16_t numOfAnchorRefsInL0; + uint16_t viewIdOfAnchorRefsInL0[STD_VIDEO_DECODE_H264_MVC_REF_LIST_SIZE]; + uint16_t numOfAnchorRefsInL1; + uint16_t viewIdOfAnchorRefsInL1[STD_VIDEO_DECODE_H264_MVC_REF_LIST_SIZE]; + uint16_t numOfNonAnchorRefsInL0; + uint16_t viewIdOfNonAnchorRefsInL0[STD_VIDEO_DECODE_H264_MVC_REF_LIST_SIZE]; + uint16_t numOfNonAnchorRefsInL1; + uint16_t viewIdOfNonAnchorRefsInL1[STD_VIDEO_DECODE_H264_MVC_REF_LIST_SIZE]; } StdVideoDecodeH264MvcElement; typedef struct StdVideoDecodeH264Mvc { - uint32_t viewId0; - uint32_t mvcElementCount; - StdVideoDecodeH264MvcElement* pMvcElements; + uint32_t viewId0; + uint32_t mvcElementCount; + StdVideoDecodeH264MvcElement* pMvcElements; } StdVideoDecodeH264Mvc; @@ -94,4 +95,4 @@ typedef struct StdVideoDecodeH264Mvc { } #endif -#endif // VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ +#endif diff --git a/include/vk_video/vulkan_video_codec_h264std_encode.h b/include/vk_video/vulkan_video_codec_h264std_encode.h index f3a0d3a..4387908 100644 --- a/include/vk_video/vulkan_video_codec_h264std_encode.h +++ b/include/vk_video/vulkan_video_codec_h264std_encode.h @@ -1,89 +1,92 @@ +#ifndef VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ +#define VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ 1 + /* -** Copyright (c) 2019-2021 The Khronos Group Inc. +** Copyright 2015-2021 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ -#ifndef VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ -#define VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ 1 +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + #ifdef __cplusplus extern "C" { #endif -#include "vk_video/vulkan_video_codec_h264std.h" -// ************************************************* -// Video H.264 Encode related parameters: -// ************************************************* +#define vulkan_video_codec_h264std_encode 1 typedef struct StdVideoEncodeH264SliceHeaderFlags { - uint32_t idr_flag : 1; - uint32_t is_reference_flag : 1; - uint32_t num_ref_idx_active_override_flag : 1; - uint32_t no_output_of_prior_pics_flag : 1; - uint32_t long_term_reference_flag : 1; - uint32_t adaptive_ref_pic_marking_mode_flag : 1; - uint32_t no_prior_references_available_flag : 1; + uint32_t idr_flag : 1; + uint32_t is_reference_flag : 1; + uint32_t num_ref_idx_active_override_flag : 1; + uint32_t no_output_of_prior_pics_flag : 1; + uint32_t long_term_reference_flag : 1; + uint32_t adaptive_ref_pic_marking_mode_flag : 1; + uint32_t no_prior_references_available_flag : 1; } StdVideoEncodeH264SliceHeaderFlags; typedef struct StdVideoEncodeH264PictureInfoFlags { - uint32_t idr_flag : 1; - uint32_t is_reference_flag : 1; - uint32_t long_term_reference_flag : 1; + uint32_t idr_flag : 1; + uint32_t is_reference_flag : 1; + uint32_t long_term_reference_flag : 1; } StdVideoEncodeH264PictureInfoFlags; typedef struct StdVideoEncodeH264RefMgmtFlags { - uint32_t ref_pic_list_modification_l0_flag : 1; - uint32_t ref_pic_list_modification_l1_flag : 1; + uint32_t ref_pic_list_modification_l0_flag : 1; + uint32_t ref_pic_list_modification_l1_flag : 1; } StdVideoEncodeH264RefMgmtFlags; typedef struct StdVideoEncodeH264RefListModEntry { - StdVideoH264ModificationOfPicNumsIdc modification_of_pic_nums_idc; - uint16_t abs_diff_pic_num_minus1; - uint16_t long_term_pic_num; + StdVideoH264ModificationOfPicNumsIdc modification_of_pic_nums_idc; + uint16_t abs_diff_pic_num_minus1; + uint16_t long_term_pic_num; } StdVideoEncodeH264RefListModEntry; typedef struct StdVideoEncodeH264RefPicMarkingEntry { - StdVideoH264MemMgmtControlOp operation; - uint16_t difference_of_pic_nums_minus1; - uint16_t long_term_pic_num; - uint16_t long_term_frame_idx; - uint16_t max_long_term_frame_idx_plus1; + StdVideoH264MemMgmtControlOp operation; + uint16_t difference_of_pic_nums_minus1; + uint16_t long_term_pic_num; + uint16_t long_term_frame_idx; + uint16_t max_long_term_frame_idx_plus1; } StdVideoEncodeH264RefPicMarkingEntry; typedef struct StdVideoEncodeH264RefMemMgmtCtrlOperations { - StdVideoEncodeH264RefMgmtFlags flags; - uint8_t refList0ModOpCount; - StdVideoEncodeH264RefListModEntry* pRefList0ModOperations; - uint8_t refList1ModOpCount; - StdVideoEncodeH264RefListModEntry* pRefList1ModOperations; - uint8_t refPicMarkingOpCount; - StdVideoEncodeH264RefPicMarkingEntry* pRefPicMarkingOperations; + StdVideoEncodeH264RefMgmtFlags flags; + uint8_t refList0ModOpCount; + StdVideoEncodeH264RefListModEntry* pRefList0ModOperations; + uint8_t refList1ModOpCount; + StdVideoEncodeH264RefListModEntry* pRefList1ModOperations; + uint8_t refPicMarkingOpCount; + StdVideoEncodeH264RefPicMarkingEntry* pRefPicMarkingOperations; } StdVideoEncodeH264RefMemMgmtCtrlOperations; typedef struct StdVideoEncodeH264PictureInfo { - StdVideoEncodeH264PictureInfoFlags flags; - StdVideoH264PictureType pictureType; - uint32_t frameNum; - uint32_t pictureOrderCount; - uint16_t long_term_pic_num; - uint16_t long_term_frame_idx; + StdVideoEncodeH264PictureInfoFlags flags; + StdVideoH264PictureType pictureType; + uint32_t frameNum; + uint32_t pictureOrderCount; + uint16_t long_term_pic_num; + uint16_t long_term_frame_idx; } StdVideoEncodeH264PictureInfo; typedef struct StdVideoEncodeH264SliceHeader { - StdVideoEncodeH264SliceHeaderFlags flags; - StdVideoH264SliceType slice_type; - uint8_t seq_parameter_set_id; - uint8_t pic_parameter_set_id; - uint16_t idr_pic_id; - uint8_t num_ref_idx_l0_active_minus1; - uint8_t num_ref_idx_l1_active_minus1; - StdVideoH264CabacInitIdc cabac_init_idc; - StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc; - int8_t slice_alpha_c0_offset_div2; - int8_t slice_beta_offset_div2; - StdVideoEncodeH264RefMemMgmtCtrlOperations* pMemMgmtCtrlOperations; + StdVideoEncodeH264SliceHeaderFlags flags; + StdVideoH264SliceType slice_type; + uint8_t seq_parameter_set_id; + uint8_t pic_parameter_set_id; + uint16_t idr_pic_id; + uint8_t num_ref_idx_l0_active_minus1; + uint8_t num_ref_idx_l1_active_minus1; + StdVideoH264CabacInitIdc cabac_init_idc; + StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc; + int8_t slice_alpha_c0_offset_div2; + int8_t slice_beta_offset_div2; + StdVideoEncodeH264RefMemMgmtCtrlOperations* pMemMgmtCtrlOperations; } StdVideoEncodeH264SliceHeader; @@ -91,4 +94,4 @@ typedef struct StdVideoEncodeH264SliceHeader { } #endif -#endif // VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ +#endif diff --git a/include/vk_video/vulkan_video_codec_h265std.h b/include/vk_video/vulkan_video_codec_h265std.h index 179c6b7..5690f36 100644 --- a/include/vk_video/vulkan_video_codec_h265std.h +++ b/include/vk_video/vulkan_video_codec_h265std.h @@ -1,27 +1,30 @@ +#ifndef VULKAN_VIDEO_CODEC_H265STD_H_ +#define VULKAN_VIDEO_CODEC_H265STD_H_ 1 + /* -** Copyright (c) 2019-2021 The Khronos Group Inc. +** Copyright 2015-2021 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ -#ifndef VULKAN_VIDEO_CODEC_H265STD_H_ -#define VULKAN_VIDEO_CODEC_H265STD_H_ 1 +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + #ifdef __cplusplus extern "C" { #endif -#include "vk_video/vulkan_video_codecs_common.h" + +#define vulkan_video_codec_h265std 1 // Vulkan 0.5 version number WIP #define VK_STD_VULKAN_VIDEO_CODEC_H265_API_VERSION_0_9_5 VK_MAKE_VIDEO_STD_VERSION(0, 9, 5) // Patch version should always be set to 0 -// Format must be in the form XX.XX where the first two digits are the major and the second two, the minor. -#define VK_STD_VULKAN_VIDEO_CODEC_H265_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_API_VERSION_0_9_5 -#define VK_STD_VULKAN_VIDEO_CODEC_H265_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265" - -#define STD_VIDEO_H265_CPB_CNT_LIST_SIZE 32 #define STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE 7 +#define STD_VIDEO_H265_CPB_CNT_LIST_SIZE 32 #define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS 6 #define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS 16 #define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS 6 @@ -30,27 +33,31 @@ extern "C" { #define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS 64 #define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS 2 #define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS 64 -#define STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE 6 -#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE 19 -#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE 21 #define STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE 3 #define STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE 128 +#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE 19 +#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE 21 +#define STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE 6 +#define VK_STD_VULKAN_VIDEO_CODEC_H265_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_API_VERSION_0_9_5 +#define VK_STD_VULKAN_VIDEO_CODEC_H265_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265" typedef enum StdVideoH265ChromaFormatIdc { - STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME = 0, - STD_VIDEO_H265_CHROMA_FORMAT_IDC_420 = 1, - STD_VIDEO_H265_CHROMA_FORMAT_IDC_422 = 2, - STD_VIDEO_H265_CHROMA_FORMAT_IDC_444 = 3, - STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF + STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME = 0, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_420 = 1, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_422 = 2, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_444 = 3, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_MAX_ENUM = 0x7FFFFFFF } StdVideoH265ChromaFormatIdc; typedef enum StdVideoH265ProfileIdc { - STD_VIDEO_H265_PROFILE_IDC_MAIN = 1, - STD_VIDEO_H265_PROFILE_IDC_MAIN_10 = 2, - STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE = 3, - STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS = 4, - STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS = 9, - STD_VIDEO_H265_PROFILE_IDC_INVALID = 0x7FFFFFFF + STD_VIDEO_H265_PROFILE_IDC_MAIN = 1, + STD_VIDEO_H265_PROFILE_IDC_MAIN_10 = 2, + STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE = 3, + STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS = 4, + STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS = 9, + STD_VIDEO_H265_PROFILE_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF } StdVideoH265ProfileIdc; typedef enum StdVideoH265Level { @@ -67,305 +74,287 @@ typedef enum StdVideoH265Level { STD_VIDEO_H265_LEVEL_6_0 = 10, STD_VIDEO_H265_LEVEL_6_1 = 11, STD_VIDEO_H265_LEVEL_6_2 = 12, - STD_VIDEO_H265_LEVEL_INVALID = 0x7FFFFFFF + STD_VIDEO_H265_LEVEL_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_LEVEL_MAX_ENUM = 0x7FFFFFFF } StdVideoH265Level; typedef enum StdVideoH265SliceType { STD_VIDEO_H265_SLICE_TYPE_B = 0, STD_VIDEO_H265_SLICE_TYPE_P = 1, STD_VIDEO_H265_SLICE_TYPE_I = 2, - STD_VIDEO_H265_SLICE_TYPE_INVALID = 0x7FFFFFFF + STD_VIDEO_H265_SLICE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_SLICE_TYPE_MAX_ENUM = 0x7FFFFFFF } StdVideoH265SliceType; typedef enum StdVideoH265PictureType { - STD_VIDEO_H265_PICTURE_TYPE_P = 0, - STD_VIDEO_H265_PICTURE_TYPE_B = 1, - STD_VIDEO_H265_PICTURE_TYPE_I = 2, + STD_VIDEO_H265_PICTURE_TYPE_P = 0, + STD_VIDEO_H265_PICTURE_TYPE_B = 1, + STD_VIDEO_H265_PICTURE_TYPE_I = 2, STD_VIDEO_H265_PICTURE_TYPE_IDR = 3, - STD_VIDEO_H265_PICTURE_TYPE_INVALID = 0x7FFFFFFF + STD_VIDEO_H265_PICTURE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_PICTURE_TYPE_MAX_ENUM = 0x7FFFFFFF } StdVideoH265PictureType; - -typedef struct StdVideoH265DecPicBufMgr -{ - uint32_t max_latency_increase_plus1[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE]; - uint8_t max_dec_pic_buffering_minus1[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE]; - uint8_t max_num_reorder_pics[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE]; +typedef struct StdVideoH265DecPicBufMgr { + uint32_t max_latency_increase_plus1[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE]; + uint8_t max_dec_pic_buffering_minus1[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE]; + uint8_t max_num_reorder_pics[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE]; } StdVideoH265DecPicBufMgr; -typedef struct StdVideoH265SubLayerHrdParameters { // sub_layer_hrd_parameters - uint32_t bit_rate_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; - uint32_t cpb_size_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; - uint32_t cpb_size_du_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; - uint32_t bit_rate_du_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; - uint32_t cbr_flag; // each bit represents a range of CpbCounts (bit 0 - cpb_cnt_minus1) per sub-layer +typedef struct StdVideoH265SubLayerHrdParameters { + uint32_t bit_rate_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; + uint32_t cpb_size_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; + uint32_t cpb_size_du_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; + uint32_t bit_rate_du_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; + uint32_t cbr_flag; } StdVideoH265SubLayerHrdParameters; typedef struct StdVideoH265HrdFlags { - uint32_t nal_hrd_parameters_present_flag : 1; - uint32_t vcl_hrd_parameters_present_flag : 1; - uint32_t sub_pic_hrd_params_present_flag : 1; - uint32_t sub_pic_cpb_params_in_pic_timing_sei_flag : 1; - uint32_t fixed_pic_rate_general_flag : 8; // each bit represents a sublayer, bit 0 - vps_max_sub_layers_minus1 - uint32_t fixed_pic_rate_within_cvs_flag : 8; // each bit represents a sublayer, bit 0 - vps_max_sub_layers_minus1 - uint32_t low_delay_hrd_flag : 8; // each bit represents a sublayer, bit 0 - vps_max_sub_layers_minus1 + uint32_t nal_hrd_parameters_present_flag : 1; + uint32_t vcl_hrd_parameters_present_flag : 1; + uint32_t sub_pic_hrd_params_present_flag : 1; + uint32_t sub_pic_cpb_params_in_pic_timing_sei_flag : 1; + uint32_t fixed_pic_rate_general_flag : 8; + uint32_t fixed_pic_rate_within_cvs_flag : 8; + uint32_t low_delay_hrd_flag : 8; } StdVideoH265HrdFlags; typedef struct StdVideoH265HrdParameters { - uint8_t tick_divisor_minus2; - uint8_t du_cpb_removal_delay_increment_length_minus1; - uint8_t dpb_output_delay_du_length_minus1; - uint8_t bit_rate_scale; - uint8_t cpb_size_scale; - uint8_t cpb_size_du_scale; - uint8_t initial_cpb_removal_delay_length_minus1; - uint8_t au_cpb_removal_delay_length_minus1; - uint8_t dpb_output_delay_length_minus1; - uint8_t cpb_cnt_minus1[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE]; - uint16_t elemental_duration_in_tc_minus1[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE]; - StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersNal[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE]; // NAL per layer ptr to sub_layer_hrd_parameters - StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersVcl[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE]; // VCL per layer ptr to sub_layer_hrd_parameters - StdVideoH265HrdFlags flags; + uint8_t tick_divisor_minus2; + uint8_t du_cpb_removal_delay_increment_length_minus1; + uint8_t dpb_output_delay_du_length_minus1; + uint8_t bit_rate_scale; + uint8_t cpb_size_scale; + uint8_t cpb_size_du_scale; + uint8_t initial_cpb_removal_delay_length_minus1; + uint8_t au_cpb_removal_delay_length_minus1; + uint8_t dpb_output_delay_length_minus1; + uint8_t cpb_cnt_minus1[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE]; + uint16_t elemental_duration_in_tc_minus1[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE]; + StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersNal[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE]; + StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersVcl[STD_VIDEO_H265_SUBLAYERS_MINUS1_LIST_SIZE]; + StdVideoH265HrdFlags flags; } StdVideoH265HrdParameters; typedef struct StdVideoH265VpsFlags { - uint32_t vps_temporal_id_nesting_flag : 1; - uint32_t vps_sub_layer_ordering_info_present_flag : 1; - uint32_t vps_timing_info_present_flag : 1; - uint32_t vps_poc_proportional_to_timing_flag : 1; + uint32_t vps_temporal_id_nesting_flag : 1; + uint32_t vps_sub_layer_ordering_info_present_flag : 1; + uint32_t vps_timing_info_present_flag : 1; + uint32_t vps_poc_proportional_to_timing_flag : 1; } StdVideoH265VpsFlags; -typedef struct StdVideoH265VideoParameterSet -{ - uint8_t vps_video_parameter_set_id; - uint8_t vps_max_sub_layers_minus1; - uint32_t vps_num_units_in_tick; - uint32_t vps_time_scale; - uint32_t vps_num_ticks_poc_diff_one_minus1; - StdVideoH265DecPicBufMgr* pDecPicBufMgr; - StdVideoH265HrdParameters* pHrdParameters; - StdVideoH265VpsFlags flags; +typedef struct StdVideoH265VideoParameterSet { + uint8_t vps_video_parameter_set_id; + uint8_t vps_max_sub_layers_minus1; + uint32_t vps_num_units_in_tick; + uint32_t vps_time_scale; + uint32_t vps_num_ticks_poc_diff_one_minus1; + StdVideoH265DecPicBufMgr* pDecPicBufMgr; + StdVideoH265HrdParameters* pHrdParameters; + StdVideoH265VpsFlags flags; } StdVideoH265VideoParameterSet; -typedef struct StdVideoH265ScalingLists -{ - uint8_t ScalingList4x4[STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS]; // ScalingList[ 0 ][ MatrixID ][ i ] (sizeID = 0) - uint8_t ScalingList8x8[STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS]; // ScalingList[ 1 ][ MatrixID ][ i ] (sizeID = 1) - uint8_t ScalingList16x16[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS]; // ScalingList[ 2 ][ MatrixID ][ i ] (sizeID = 2) - uint8_t ScalingList32x32[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS]; // ScalingList[ 3 ][ MatrixID ][ i ] (sizeID = 3) - uint8_t ScalingListDCCoef16x16[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS]; // scaling_list_dc_coef_minus8[ sizeID - 2 ][ matrixID ] + 8, sizeID = 2 - uint8_t ScalingListDCCoef32x32[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS]; // scaling_list_dc_coef_minus8[ sizeID - 2 ][ matrixID ] + 8. sizeID = 3 +typedef struct StdVideoH265ScalingLists { + uint8_t ScalingList4x4[STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS]; + uint8_t ScalingList8x8[STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS]; + uint8_t ScalingList16x16[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS]; + uint8_t ScalingList32x32[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS]; + uint8_t ScalingListDCCoef16x16[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS]; + uint8_t ScalingListDCCoef32x32[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS]; } StdVideoH265ScalingLists; typedef struct StdVideoH265SpsVuiFlags { - uint32_t aspect_ratio_info_present_flag : 1; - uint32_t overscan_info_present_flag : 1; - uint32_t overscan_appropriate_flag : 1; - uint32_t video_signal_type_present_flag : 1; - uint32_t video_full_range_flag : 1; - uint32_t colour_description_present_flag : 1; - uint32_t chroma_loc_info_present_flag : 1; - uint32_t neutral_chroma_indication_flag : 1; - uint32_t field_seq_flag : 1; - uint32_t frame_field_info_present_flag : 1; - uint32_t default_display_window_flag : 1; - uint32_t vui_timing_info_present_flag : 1; - uint32_t vui_poc_proportional_to_timing_flag : 1; - uint32_t vui_hrd_parameters_present_flag : 1; - uint32_t bitstream_restriction_flag : 1; - uint32_t tiles_fixed_structure_flag : 1; - uint32_t motion_vectors_over_pic_boundaries_flag : 1; - uint32_t restricted_ref_pic_lists_flag : 1; + uint32_t aspect_ratio_info_present_flag : 1; + uint32_t overscan_info_present_flag : 1; + uint32_t overscan_appropriate_flag : 1; + uint32_t video_signal_type_present_flag : 1; + uint32_t video_full_range_flag : 1; + uint32_t colour_description_present_flag : 1; + uint32_t chroma_loc_info_present_flag : 1; + uint32_t neutral_chroma_indication_flag : 1; + uint32_t field_seq_flag : 1; + uint32_t frame_field_info_present_flag : 1; + uint32_t default_display_window_flag : 1; + uint32_t vui_timing_info_present_flag : 1; + uint32_t vui_poc_proportional_to_timing_flag : 1; + uint32_t vui_hrd_parameters_present_flag : 1; + uint32_t bitstream_restriction_flag : 1; + uint32_t tiles_fixed_structure_flag : 1; + uint32_t motion_vectors_over_pic_boundaries_flag : 1; + uint32_t restricted_ref_pic_lists_flag : 1; } StdVideoH265SpsVuiFlags; typedef struct StdVideoH265SequenceParameterSetVui { - uint8_t aspect_ratio_idc; - uint16_t sar_width; - uint16_t sar_height; - uint8_t video_format; - uint8_t colour_primaries; - uint8_t transfer_characteristics; - uint8_t matrix_coeffs; - uint8_t chroma_sample_loc_type_top_field; - uint8_t chroma_sample_loc_type_bottom_field; - uint16_t def_disp_win_left_offset; - uint16_t def_disp_win_right_offset; - uint16_t def_disp_win_top_offset; - uint16_t def_disp_win_bottom_offset; - uint32_t vui_num_units_in_tick; - uint32_t vui_time_scale; - uint32_t vui_num_ticks_poc_diff_one_minus1; - StdVideoH265HrdParameters* pHrdParameters; - uint16_t min_spatial_segmentation_idc; - uint8_t max_bytes_per_pic_denom; - uint8_t max_bits_per_min_cu_denom; - uint8_t log2_max_mv_length_horizontal; - uint8_t log2_max_mv_length_vertical; - StdVideoH265SpsVuiFlags flags; + uint8_t aspect_ratio_idc; + uint16_t sar_width; + uint16_t sar_height; + uint8_t video_format; + uint8_t colour_primaries; + uint8_t transfer_characteristics; + uint8_t matrix_coeffs; + uint8_t chroma_sample_loc_type_top_field; + uint8_t chroma_sample_loc_type_bottom_field; + uint16_t def_disp_win_left_offset; + uint16_t def_disp_win_right_offset; + uint16_t def_disp_win_top_offset; + uint16_t def_disp_win_bottom_offset; + uint32_t vui_num_units_in_tick; + uint32_t vui_time_scale; + uint32_t vui_num_ticks_poc_diff_one_minus1; + StdVideoH265HrdParameters* pHrdParameters; + uint16_t min_spatial_segmentation_idc; + uint8_t max_bytes_per_pic_denom; + uint8_t max_bits_per_min_cu_denom; + uint8_t log2_max_mv_length_horizontal; + uint8_t log2_max_mv_length_vertical; + StdVideoH265SpsVuiFlags flags; } StdVideoH265SequenceParameterSetVui; -typedef struct StdVideoH265PredictorPaletteEntries -{ - uint16_t PredictorPaletteEntries[STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE][STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE]; +typedef struct StdVideoH265PredictorPaletteEntries { + uint16_t PredictorPaletteEntries[STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE][STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE]; } StdVideoH265PredictorPaletteEntries; typedef struct StdVideoH265SpsFlags { - uint32_t sps_temporal_id_nesting_flag : 1; - uint32_t separate_colour_plane_flag : 1; - uint32_t scaling_list_enabled_flag : 1; - uint32_t sps_scaling_list_data_present_flag : 1; - uint32_t amp_enabled_flag : 1; - uint32_t sample_adaptive_offset_enabled_flag : 1; - uint32_t pcm_enabled_flag : 1; - uint32_t pcm_loop_filter_disabled_flag : 1; - uint32_t long_term_ref_pics_present_flag : 1; - uint32_t sps_temporal_mvp_enabled_flag : 1; - uint32_t strong_intra_smoothing_enabled_flag : 1; - uint32_t vui_parameters_present_flag : 1; - uint32_t sps_extension_present_flag : 1; - uint32_t sps_range_extension_flag : 1; - - // extension SPS flags, valid when STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS is set - uint32_t transform_skip_rotation_enabled_flag : 1; - uint32_t transform_skip_context_enabled_flag : 1; - uint32_t implicit_rdpcm_enabled_flag : 1; - uint32_t explicit_rdpcm_enabled_flag : 1; - uint32_t extended_precision_processing_flag : 1; - uint32_t intra_smoothing_disabled_flag : 1; - uint32_t high_precision_offsets_enabled_flag : 1; - uint32_t persistent_rice_adaptation_enabled_flag : 1; - uint32_t cabac_bypass_alignment_enabled_flag : 1; - - // extension SPS flags, valid when STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS is set - uint32_t sps_curr_pic_ref_enabled_flag : 1; - uint32_t palette_mode_enabled_flag : 1; - uint32_t sps_palette_predictor_initializer_present_flag : 1; - uint32_t intra_boundary_filtering_disabled_flag : 1; + uint32_t sps_temporal_id_nesting_flag : 1; + uint32_t separate_colour_plane_flag : 1; + uint32_t scaling_list_enabled_flag : 1; + uint32_t sps_scaling_list_data_present_flag : 1; + uint32_t amp_enabled_flag : 1; + uint32_t sample_adaptive_offset_enabled_flag : 1; + uint32_t pcm_enabled_flag : 1; + uint32_t pcm_loop_filter_disabled_flag : 1; + uint32_t long_term_ref_pics_present_flag : 1; + uint32_t sps_temporal_mvp_enabled_flag : 1; + uint32_t strong_intra_smoothing_enabled_flag : 1; + uint32_t vui_parameters_present_flag : 1; + uint32_t sps_extension_present_flag : 1; + uint32_t sps_range_extension_flag : 1; + uint32_t transform_skip_rotation_enabled_flag : 1; + uint32_t transform_skip_context_enabled_flag : 1; + uint32_t implicit_rdpcm_enabled_flag : 1; + uint32_t explicit_rdpcm_enabled_flag : 1; + uint32_t extended_precision_processing_flag : 1; + uint32_t intra_smoothing_disabled_flag : 1; + uint32_t high_precision_offsets_enabled_flag : 1; + uint32_t persistent_rice_adaptation_enabled_flag : 1; + uint32_t cabac_bypass_alignment_enabled_flag : 1; + uint32_t sps_curr_pic_ref_enabled_flag : 1; + uint32_t palette_mode_enabled_flag : 1; + uint32_t sps_palette_predictor_initializer_present_flag : 1; + uint32_t intra_boundary_filtering_disabled_flag : 1; } StdVideoH265SpsFlags; -typedef struct StdVideoH265SequenceParameterSet -{ - StdVideoH265ProfileIdc profile_idc; - StdVideoH265Level level_idc; - uint32_t pic_width_in_luma_samples; - uint32_t pic_height_in_luma_samples; - uint8_t sps_video_parameter_set_id; - uint8_t sps_max_sub_layers_minus1; - uint8_t sps_seq_parameter_set_id; - uint8_t chroma_format_idc; - uint8_t bit_depth_luma_minus8; - uint8_t bit_depth_chroma_minus8; - uint8_t log2_max_pic_order_cnt_lsb_minus4; - uint8_t sps_max_dec_pic_buffering_minus1; - uint8_t log2_min_luma_coding_block_size_minus3; - uint8_t log2_diff_max_min_luma_coding_block_size; - uint8_t log2_min_luma_transform_block_size_minus2; - uint8_t log2_diff_max_min_luma_transform_block_size; - uint8_t max_transform_hierarchy_depth_inter; - uint8_t max_transform_hierarchy_depth_intra; - uint8_t num_short_term_ref_pic_sets; - uint8_t num_long_term_ref_pics_sps; - uint8_t pcm_sample_bit_depth_luma_minus1; - uint8_t pcm_sample_bit_depth_chroma_minus1; - uint8_t log2_min_pcm_luma_coding_block_size_minus3; - uint8_t log2_diff_max_min_pcm_luma_coding_block_size; - uint32_t conf_win_left_offset; - uint32_t conf_win_right_offset; - uint32_t conf_win_top_offset; - uint32_t conf_win_bottom_offset; - StdVideoH265DecPicBufMgr* pDecPicBufMgr; - StdVideoH265SpsFlags flags; - StdVideoH265ScalingLists* pScalingLists; // Must be a valid pointer if sps_scaling_list_data_present_flag is set - StdVideoH265SequenceParameterSetVui* pSequenceParameterSetVui; // Must be a valid pointer if StdVideoH265SpsFlags:vui_parameters_present_flag is set palette_max_size; - - // extension SPS flags, valid when STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS is set - uint8_t palette_max_size; - uint8_t delta_palette_max_predictor_size; - uint8_t motion_vector_resolution_control_idc; - uint8_t sps_num_palette_predictor_initializer_minus1; - StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; // Must be a valid pointer if sps_palette_predictor_initializer_present_flag is set +typedef struct StdVideoH265SequenceParameterSet { + StdVideoH265ProfileIdc profile_idc; + StdVideoH265Level level_idc; + uint32_t pic_width_in_luma_samples; + uint32_t pic_height_in_luma_samples; + uint8_t sps_video_parameter_set_id; + uint8_t sps_max_sub_layers_minus1; + uint8_t sps_seq_parameter_set_id; + uint8_t chroma_format_idc; + uint8_t bit_depth_luma_minus8; + uint8_t bit_depth_chroma_minus8; + uint8_t log2_max_pic_order_cnt_lsb_minus4; + uint8_t sps_max_dec_pic_buffering_minus1; + uint8_t log2_min_luma_coding_block_size_minus3; + uint8_t log2_diff_max_min_luma_coding_block_size; + uint8_t log2_min_luma_transform_block_size_minus2; + uint8_t log2_diff_max_min_luma_transform_block_size; + uint8_t max_transform_hierarchy_depth_inter; + uint8_t max_transform_hierarchy_depth_intra; + uint8_t num_short_term_ref_pic_sets; + uint8_t num_long_term_ref_pics_sps; + uint8_t pcm_sample_bit_depth_luma_minus1; + uint8_t pcm_sample_bit_depth_chroma_minus1; + uint8_t log2_min_pcm_luma_coding_block_size_minus3; + uint8_t log2_diff_max_min_pcm_luma_coding_block_size; + uint32_t conf_win_left_offset; + uint32_t conf_win_right_offset; + uint32_t conf_win_top_offset; + uint32_t conf_win_bottom_offset; + StdVideoH265DecPicBufMgr* pDecPicBufMgr; + StdVideoH265SpsFlags flags; + StdVideoH265ScalingLists* pScalingLists; + StdVideoH265SequenceParameterSetVui* pSequenceParameterSetVui; + uint8_t palette_max_size; + uint8_t delta_palette_max_predictor_size; + uint8_t motion_vector_resolution_control_idc; + uint8_t sps_num_palette_predictor_initializer_minus1; + StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; } StdVideoH265SequenceParameterSet; - typedef struct StdVideoH265PpsFlags { - uint32_t dependent_slice_segments_enabled_flag : 1; - uint32_t output_flag_present_flag : 1; - uint32_t sign_data_hiding_enabled_flag : 1; - uint32_t cabac_init_present_flag : 1; - uint32_t constrained_intra_pred_flag : 1; - uint32_t transform_skip_enabled_flag : 1; - uint32_t cu_qp_delta_enabled_flag : 1; - uint32_t pps_slice_chroma_qp_offsets_present_flag : 1; - uint32_t weighted_pred_flag : 1; - uint32_t weighted_bipred_flag : 1; - uint32_t transquant_bypass_enabled_flag : 1; - uint32_t tiles_enabled_flag : 1; - uint32_t entropy_coding_sync_enabled_flag : 1; - uint32_t uniform_spacing_flag : 1; - uint32_t loop_filter_across_tiles_enabled_flag : 1; - uint32_t pps_loop_filter_across_slices_enabled_flag : 1; - uint32_t deblocking_filter_control_present_flag : 1; - uint32_t deblocking_filter_override_enabled_flag : 1; - uint32_t pps_deblocking_filter_disabled_flag : 1; - uint32_t pps_scaling_list_data_present_flag : 1; - uint32_t lists_modification_present_flag : 1; - uint32_t slice_segment_header_extension_present_flag : 1; - uint32_t pps_extension_present_flag : 1; - - // extension PPS flags, valid when STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS is set - uint32_t cross_component_prediction_enabled_flag : 1; - uint32_t chroma_qp_offset_list_enabled_flag : 1; - - // extension PPS flags, valid when STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS is set - uint32_t pps_curr_pic_ref_enabled_flag : 1; - uint32_t residual_adaptive_colour_transform_enabled_flag : 1; - uint32_t pps_slice_act_qp_offsets_present_flag : 1; - uint32_t pps_palette_predictor_initializer_present_flag : 1; - uint32_t monochrome_palette_flag : 1; - uint32_t pps_range_extension_flag : 1; + uint32_t dependent_slice_segments_enabled_flag : 1; + uint32_t output_flag_present_flag : 1; + uint32_t sign_data_hiding_enabled_flag : 1; + uint32_t cabac_init_present_flag : 1; + uint32_t constrained_intra_pred_flag : 1; + uint32_t transform_skip_enabled_flag : 1; + uint32_t cu_qp_delta_enabled_flag : 1; + uint32_t pps_slice_chroma_qp_offsets_present_flag : 1; + uint32_t weighted_pred_flag : 1; + uint32_t weighted_bipred_flag : 1; + uint32_t transquant_bypass_enabled_flag : 1; + uint32_t tiles_enabled_flag : 1; + uint32_t entropy_coding_sync_enabled_flag : 1; + uint32_t uniform_spacing_flag : 1; + uint32_t loop_filter_across_tiles_enabled_flag : 1; + uint32_t pps_loop_filter_across_slices_enabled_flag : 1; + uint32_t deblocking_filter_control_present_flag : 1; + uint32_t deblocking_filter_override_enabled_flag : 1; + uint32_t pps_deblocking_filter_disabled_flag : 1; + uint32_t pps_scaling_list_data_present_flag : 1; + uint32_t lists_modification_present_flag : 1; + uint32_t slice_segment_header_extension_present_flag : 1; + uint32_t pps_extension_present_flag : 1; + uint32_t cross_component_prediction_enabled_flag : 1; + uint32_t chroma_qp_offset_list_enabled_flag : 1; + uint32_t pps_curr_pic_ref_enabled_flag : 1; + uint32_t residual_adaptive_colour_transform_enabled_flag : 1; + uint32_t pps_slice_act_qp_offsets_present_flag : 1; + uint32_t pps_palette_predictor_initializer_present_flag : 1; + uint32_t monochrome_palette_flag : 1; + uint32_t pps_range_extension_flag : 1; } StdVideoH265PpsFlags; -typedef struct StdVideoH265PictureParameterSet -{ - uint8_t pps_pic_parameter_set_id; - uint8_t pps_seq_parameter_set_id; - uint8_t num_extra_slice_header_bits; - uint8_t num_ref_idx_l0_default_active_minus1; - uint8_t num_ref_idx_l1_default_active_minus1; - int8_t init_qp_minus26; - uint8_t diff_cu_qp_delta_depth; - int8_t pps_cb_qp_offset; - int8_t pps_cr_qp_offset; - uint8_t num_tile_columns_minus1; - uint8_t num_tile_rows_minus1; - uint16_t column_width_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE]; - uint16_t row_height_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE]; - int8_t pps_beta_offset_div2; - int8_t pps_tc_offset_div2; - uint8_t log2_parallel_merge_level_minus2; - StdVideoH265PpsFlags flags; - StdVideoH265ScalingLists* pScalingLists; // Must be a valid pointer if pps_scaling_list_data_present_flag is set - - // extension PPS, valid when STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS is set - uint8_t log2_max_transform_skip_block_size_minus2; - uint8_t diff_cu_chroma_qp_offset_depth; - uint8_t chroma_qp_offset_list_len_minus1; - int8_t cb_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]; - int8_t cr_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]; - uint8_t log2_sao_offset_scale_luma; - uint8_t log2_sao_offset_scale_chroma; - - // extension PPS, valid when STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS is set - int8_t pps_act_y_qp_offset_plus5; - int8_t pps_act_cb_qp_offset_plus5; - int8_t pps_act_cr_qp_offset_plus5; - uint8_t pps_num_palette_predictor_initializer; - uint8_t luma_bit_depth_entry_minus8; - uint8_t chroma_bit_depth_entry_minus8; - StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; // Must be a valid pointer if pps_palette_predictor_initializer_present_flag is set +typedef struct StdVideoH265PictureParameterSet { + uint8_t pps_pic_parameter_set_id; + uint8_t pps_seq_parameter_set_id; + uint8_t num_extra_slice_header_bits; + uint8_t num_ref_idx_l0_default_active_minus1; + uint8_t num_ref_idx_l1_default_active_minus1; + int8_t init_qp_minus26; + uint8_t diff_cu_qp_delta_depth; + int8_t pps_cb_qp_offset; + int8_t pps_cr_qp_offset; + uint8_t num_tile_columns_minus1; + uint8_t num_tile_rows_minus1; + uint16_t column_width_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE]; + uint16_t row_height_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE]; + int8_t pps_beta_offset_div2; + int8_t pps_tc_offset_div2; + uint8_t log2_parallel_merge_level_minus2; + StdVideoH265PpsFlags flags; + StdVideoH265ScalingLists* pScalingLists; + uint8_t log2_max_transform_skip_block_size_minus2; + uint8_t diff_cu_chroma_qp_offset_depth; + uint8_t chroma_qp_offset_list_len_minus1; + int8_t cb_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]; + int8_t cr_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]; + uint8_t log2_sao_offset_scale_luma; + uint8_t log2_sao_offset_scale_chroma; + int8_t pps_act_y_qp_offset_plus5; + int8_t pps_act_cb_qp_offset_plus5; + int8_t pps_act_cr_qp_offset_plus5; + uint8_t pps_num_palette_predictor_initializer; + uint8_t luma_bit_depth_entry_minus8; + uint8_t chroma_bit_depth_entry_minus8; + StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; } StdVideoH265PictureParameterSet; + #ifdef __cplusplus } #endif -#endif // VULKAN_VIDEO_CODEC_H265STD_H_ +#endif diff --git a/include/vk_video/vulkan_video_codec_h265std_decode.h b/include/vk_video/vulkan_video_codec_h265std_decode.h index a1efa05..ff06b11 100644 --- a/include/vk_video/vulkan_video_codec_h265std_decode.h +++ b/include/vk_video/vulkan_video_codec_h265std_decode.h @@ -1,64 +1,60 @@ +#ifndef VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ +#define VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ 1 + /* -** Copyright (c) 2019-2021 The Khronos Group Inc. +** Copyright 2015-2021 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ -#ifndef VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ -#define VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ 1 +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + #ifdef __cplusplus extern "C" { #endif -#include "vk_video/vulkan_video_codec_h265std.h" -// ************************************************* -// Video h265 Decode related parameters: -// ************************************************* +#define vulkan_video_codec_h265std_decode 1 #define STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE 8 - typedef struct StdVideoDecodeH265PictureInfoFlags { - uint32_t IrapPicFlag : 1; - uint32_t IdrPicFlag : 1; - uint32_t IsReference : 1; - uint32_t short_term_ref_pic_set_sps_flag : 1; + uint32_t IrapPicFlag : 1; + uint32_t IdrPicFlag : 1; + uint32_t IsReference : 1; + uint32_t short_term_ref_pic_set_sps_flag : 1; } StdVideoDecodeH265PictureInfoFlags; typedef struct StdVideoDecodeH265PictureInfo { - uint8_t vps_video_parameter_set_id; - uint8_t sps_seq_parameter_set_id; - uint8_t pps_pic_parameter_set_id; - uint8_t num_short_term_ref_pic_sets; - int32_t PicOrderCntVal; - uint16_t NumBitsForSTRefPicSetInSlice; // number of bits used in st_ref_pic_set() - //when short_term_ref_pic_set_sps_flag is 0; otherwise set to 0. - uint8_t NumDeltaPocsOfRefRpsIdx; // NumDeltaPocs[ RefRpsIdx ] when short_term_ref_pic_set_sps_flag = 1, otherwise 0 - uint8_t RefPicSetStCurrBefore[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; // slotIndex as used in - // VkVideoReferenceSlotKHR structures representing - //pReferenceSlots in VkVideoDecodeInfoKHR, 0xff for invalid slotIndex - uint8_t RefPicSetStCurrAfter[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; // slotIndex as used in - // VkVideoReferenceSlotKHR structures representing - //pReferenceSlots in VkVideoDecodeInfoKHR, 0xff for invalid slotIndex - uint8_t RefPicSetLtCurr[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; // slotIndex as used in - // VkVideoReferenceSlotKHR structures representing - //pReferenceSlots in VkVideoDecodeInfoKHR, 0xff for invalid slotIndex - StdVideoDecodeH265PictureInfoFlags flags; + uint8_t vps_video_parameter_set_id; + uint8_t sps_seq_parameter_set_id; + uint8_t pps_pic_parameter_set_id; + uint8_t num_short_term_ref_pic_sets; + int32_t PicOrderCntVal; + uint16_t NumBitsForSTRefPicSetInSlice; + uint8_t NumDeltaPocsOfRefRpsIdx; + uint8_t RefPicSetStCurrBefore[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; + uint8_t RefPicSetStCurrAfter[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; + uint8_t RefPicSetLtCurr[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; + StdVideoDecodeH265PictureInfoFlags flags; } StdVideoDecodeH265PictureInfo; typedef struct StdVideoDecodeH265ReferenceInfoFlags { - uint32_t is_long_term : 1; - uint32_t is_non_existing : 1; + uint32_t is_long_term : 1; + uint32_t is_non_existing : 1; } StdVideoDecodeH265ReferenceInfoFlags; typedef struct StdVideoDecodeH265ReferenceInfo { - int32_t PicOrderCntVal; - StdVideoDecodeH265ReferenceInfoFlags flags; + int32_t PicOrderCntVal; + StdVideoDecodeH265ReferenceInfoFlags flags; } StdVideoDecodeH265ReferenceInfo; + #ifdef __cplusplus } #endif -#endif // VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ +#endif diff --git a/include/vk_video/vulkan_video_codec_h265std_encode.h b/include/vk_video/vulkan_video_codec_h265std_encode.h index ffffef2..d867751 100644 --- a/include/vk_video/vulkan_video_codec_h265std_encode.h +++ b/include/vk_video/vulkan_video_codec_h265std_encode.h @@ -1,122 +1,125 @@ +#ifndef VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ +#define VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ 1 + /* -** Copyright (c) 2019-2021 The Khronos Group Inc. +** Copyright 2015-2021 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ -#ifndef VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ -#define VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ 1 +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + #ifdef __cplusplus extern "C" { #endif -#include "vk_video/vulkan_video_codec_h265std.h" -// ************************************************* -// Video h265 Encode related parameters: -// ************************************************* -#define STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE 15 +#define vulkan_video_codec_h265std_encode 1 +#define STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE 15 #define STD_VIDEO_ENCODE_H265_CHROMA_LIST_SIZE 15 -#define STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM 2 - +#define STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM 2 typedef struct StdVideoEncodeH265SliceHeaderFlags { - uint32_t first_slice_segment_in_pic_flag : 1; - uint32_t no_output_of_prior_pics_flag : 1; - uint32_t dependent_slice_segment_flag : 1; - uint32_t short_term_ref_pic_set_sps_flag : 1; - uint32_t slice_temporal_mvp_enable_flag : 1; - uint32_t slice_sao_luma_flag : 1; - uint32_t slice_sao_chroma_flag : 1; - uint32_t num_ref_idx_active_override_flag : 1; - uint32_t mvd_l1_zero_flag : 1; - uint32_t cabac_init_flag : 1; - uint32_t slice_deblocking_filter_disable_flag : 1; - uint32_t collocated_from_l0_flag : 1; - uint32_t slice_loop_filter_across_slices_enabled_flag : 1; - uint32_t bLastSliceInPic : 1; - uint32_t reservedBits : 18; - uint16_t luma_weight_l0_flag; // bit 0 - num_ref_idx_l0_active_minus1 - uint16_t chroma_weight_l0_flag; // bit 0 - num_ref_idx_l0_active_minus1 - uint16_t luma_weight_l1_flag; // bit 0 - num_ref_idx_l1_active_minus1 - uint16_t chroma_weight_l1_flag; // bit 0 - num_ref_idx_l1_active_minus1 + uint32_t first_slice_segment_in_pic_flag : 1; + uint32_t no_output_of_prior_pics_flag : 1; + uint32_t dependent_slice_segment_flag : 1; + uint32_t short_term_ref_pic_set_sps_flag : 1; + uint32_t slice_temporal_mvp_enable_flag : 1; + uint32_t slice_sao_luma_flag : 1; + uint32_t slice_sao_chroma_flag : 1; + uint32_t num_ref_idx_active_override_flag : 1; + uint32_t mvd_l1_zero_flag : 1; + uint32_t cabac_init_flag : 1; + uint32_t slice_deblocking_filter_disable_flag : 1; + uint32_t collocated_from_l0_flag : 1; + uint32_t slice_loop_filter_across_slices_enabled_flag : 1; + uint32_t bLastSliceInPic : 1; + uint32_t reservedBits : 18; + uint16_t luma_weight_l0_flag; + uint16_t chroma_weight_l0_flag; + uint16_t luma_weight_l1_flag; + uint16_t chroma_weight_l1_flag; } StdVideoEncodeH265SliceHeaderFlags; typedef struct StdVideoEncodeH265SliceHeader { - StdVideoH265SliceType slice_type; - uint8_t slice_pic_parameter_set_id; - uint8_t num_short_term_ref_pic_sets; - uint32_t slice_segment_address; - uint8_t short_term_ref_pic_set_idx; - uint8_t num_long_term_sps; - uint8_t num_long_term_pics; - uint8_t collocated_ref_idx; - uint8_t num_ref_idx_l0_active_minus1; // [0, 14] - uint8_t num_ref_idx_l1_active_minus1; // [0, 14] - uint8_t luma_log2_weight_denom; // [0, 7] - int8_t delta_chroma_log2_weight_denom; - int8_t delta_luma_weight_l0[STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE]; - int8_t luma_offset_l0[STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE]; - int8_t delta_chroma_weight_l0[STD_VIDEO_ENCODE_H265_CHROMA_LIST_SIZE][STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM]; - int8_t delta_chroma_offset_l0[STD_VIDEO_ENCODE_H265_CHROMA_LIST_SIZE][STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM]; - int8_t delta_luma_weight_l1[STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE]; - int8_t luma_offset_l1[STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE]; - int8_t delta_chroma_weight_l1[STD_VIDEO_ENCODE_H265_CHROMA_LIST_SIZE][STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM]; - int8_t delta_chroma_offset_l1[STD_VIDEO_ENCODE_H265_CHROMA_LIST_SIZE][STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM]; - uint8_t MaxNumMergeCand; - int8_t slice_qp_delta; - int8_t slice_cb_qp_offset; // [-12, 12] - int8_t slice_cr_qp_offset; // [-12, 12] - int8_t slice_beta_offset_div2; // [-6, 6] - int8_t slice_tc_offset_div2; // [-6, 6] - int8_t slice_act_y_qp_offset; - int8_t slice_act_cb_qp_offset; - int8_t slice_act_cr_qp_offset; - StdVideoEncodeH265SliceHeaderFlags flags; + StdVideoH265SliceType slice_type; + uint8_t slice_pic_parameter_set_id; + uint8_t num_short_term_ref_pic_sets; + uint32_t slice_segment_address; + uint8_t short_term_ref_pic_set_idx; + uint8_t num_long_term_sps; + uint8_t num_long_term_pics; + uint8_t collocated_ref_idx; + uint8_t num_ref_idx_l0_active_minus1; + uint8_t num_ref_idx_l1_active_minus1; + uint8_t luma_log2_weight_denom; + int8_t delta_chroma_log2_weight_denom; + int8_t delta_luma_weight_l0[STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE]; + int8_t luma_offset_l0[STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE]; + int8_t delta_chroma_weight_l0[STD_VIDEO_ENCODE_H265_CHROMA_LIST_SIZE][STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM]; + int8_t delta_chroma_offset_l0[STD_VIDEO_ENCODE_H265_CHROMA_LIST_SIZE][STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM]; + int8_t delta_luma_weight_l1[STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE]; + int8_t luma_offset_l1[STD_VIDEO_ENCODE_H265_LUMA_LIST_SIZE]; + int8_t delta_chroma_weight_l1[STD_VIDEO_ENCODE_H265_CHROMA_LIST_SIZE][STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM]; + int8_t delta_chroma_offset_l1[STD_VIDEO_ENCODE_H265_CHROMA_LIST_SIZE][STD_VIDEO_ENCODE_H265_CHROMA_LISTS_NUM]; + uint8_t MaxNumMergeCand; + int8_t slice_qp_delta; + int8_t slice_cb_qp_offset; + int8_t slice_cr_qp_offset; + int8_t slice_beta_offset_div2; + int8_t slice_tc_offset_div2; + int8_t slice_act_y_qp_offset; + int8_t slice_act_cb_qp_offset; + int8_t slice_act_cr_qp_offset; + StdVideoEncodeH265SliceHeaderFlags flags; } StdVideoEncodeH265SliceHeader; typedef struct StdVideoEncodeH265ReferenceModificationFlags { - uint32_t ref_pic_list_modification_flag_l0 : 1; - uint32_t ref_pic_list_modification_flag_l1 : 1; + uint32_t ref_pic_list_modification_flag_l0 : 1; + uint32_t ref_pic_list_modification_flag_l1 : 1; } StdVideoEncodeH265ReferenceModificationFlags; typedef struct StdVideoEncodeH265ReferenceModifications { - StdVideoEncodeH265ReferenceModificationFlags flags; - uint8_t referenceList0ModificationsCount; // num_ref_idx_l0_active_minus1 - uint8_t* pReferenceList0Modifications; // list_entry_l0 - uint8_t referenceList1ModificationsCount; // num_ref_idx_l1_active_minus1 - uint8_t* pReferenceList1Modifications; // list_entry_l1 + StdVideoEncodeH265ReferenceModificationFlags flags; + uint8_t referenceList0ModificationsCount; + uint8_t* pReferenceList0Modifications; + uint8_t referenceList1ModificationsCount; + uint8_t* pReferenceList1Modifications; } StdVideoEncodeH265ReferenceModifications; typedef struct StdVideoEncodeH265PictureInfoFlags { - uint32_t is_reference_flag : 1; - uint32_t IrapPicFlag : 1; - uint32_t long_term_flag : 1; + uint32_t is_reference_flag : 1; + uint32_t IrapPicFlag : 1; + uint32_t long_term_flag : 1; } StdVideoEncodeH265PictureInfoFlags; typedef struct StdVideoEncodeH265PictureInfo { - StdVideoH265PictureType PictureType; - uint8_t sps_video_parameter_set_id; - uint8_t pps_seq_parameter_set_id; - int32_t PicOrderCntVal; - uint8_t TemporalId; - StdVideoEncodeH265PictureInfoFlags flags; + StdVideoH265PictureType PictureType; + uint8_t sps_video_parameter_set_id; + uint8_t pps_seq_parameter_set_id; + int32_t PicOrderCntVal; + uint8_t TemporalId; + StdVideoEncodeH265PictureInfoFlags flags; } StdVideoEncodeH265PictureInfo; typedef struct StdVideoEncodeH265ReferenceInfoFlags { - uint32_t is_long_term : 1; - uint32_t isUsedFlag : 1; + uint32_t is_long_term : 1; + uint32_t isUsedFlag : 1; } StdVideoEncodeH265ReferenceInfoFlags; typedef struct StdVideoEncodeH265ReferenceInfo { - int32_t PicOrderCntVal; - uint8_t TemporalId; - StdVideoEncodeH265ReferenceInfoFlags flags; + int32_t PicOrderCntVal; + uint8_t TemporalId; + StdVideoEncodeH265ReferenceInfoFlags flags; } StdVideoEncodeH265ReferenceInfo; + #ifdef __cplusplus } #endif -#endif // VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ +#endif diff --git a/include/vk_video/vulkan_video_codecs_common.h b/include/vk_video/vulkan_video_codecs_common.h index 8cc227a..b7efd16 100644 --- a/include/vk_video/vulkan_video_codecs_common.h +++ b/include/vk_video/vulkan_video_codecs_common.h @@ -1,21 +1,31 @@ +#ifndef VULKAN_VIDEO_CODECS_COMMON_H_ +#define VULKAN_VIDEO_CODECS_COMMON_H_ 1 + /* -** Copyright (c) 2019-2021 The Khronos Group Inc. +** Copyright 2015-2021 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ -#ifndef VULKAN_VIDEO_CODEC_COMMON_H_ -#define VULKAN_VIDEO_CODEC_COMMON_H_ 1 +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + #ifdef __cplusplus extern "C" { #endif + + +#define vulkan_video_codecs_common 1 #define VK_MAKE_VIDEO_STD_VERSION(major, minor, patch) \ ((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch))) + #ifdef __cplusplus } #endif -#endif // VULKAN_VIDEO_CODEC_COMMON_H_ +#endif diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp index 0445ff1..dbb9e89 100644 --- a/include/vulkan/vulkan.hpp +++ b/include/vulkan/vulkan.hpp @@ -119,7 +119,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h # include #endif -static_assert( VK_HEADER_VERSION == 202, "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 203, "Wrong VK_HEADER_VERSION!" ); // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION @@ -234,11 +234,6 @@ static_assert( VK_HEADER_VERSION == 202, "Wrong VK_HEADER_VERSION!" ); # define VULKAN_HPP_NAMESPACE vk #endif -#if !defined( VULKAN_HPP_HASH_COMBINE ) -# define VULKAN_HPP_HASH_COMBINE( valueType, seed, value ) \ - seed ^= std::hash::type>{}( value ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 ) -#endif - #define VULKAN_HPP_STRINGIFY2( text ) #text #define VULKAN_HPP_STRINGIFY( text ) VULKAN_HPP_STRINGIFY2( text ) #define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE ) @@ -818,20 +813,7 @@ namespace VULKAN_HPP_NAMESPACE { return flags.operator^( bit ); } -} // namespace VULKAN_HPP_NAMESPACE - -template -struct std::hash> -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::Flags const & flags ) const VULKAN_HPP_NOEXCEPT - { - return std::hash::type>{}( - static_cast::type>( flags ) ); - } -}; -namespace VULKAN_HPP_NAMESPACE -{ template class Optional { @@ -7446,6 +7428,14 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_KHR_video_queue === template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> struct StructExtends { enum @@ -11030,6 +11020,58 @@ namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_QCOM_fragment_density_map_offset === + 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_NV_linear_color_attachment === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL class DynamicLoader { diff --git a/include/vulkan/vulkan_beta.h b/include/vulkan/vulkan_beta.h index 3b1a55a..26dbdb8 100644 --- a/include/vulkan/vulkan_beta.h +++ b/include/vulkan/vulkan_beta.h @@ -99,6 +99,12 @@ typedef enum VkVideoCodingQualityPresetFlagBitsKHR { VK_VIDEO_CODING_QUALITY_PRESET_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkVideoCodingQualityPresetFlagBitsKHR; typedef VkFlags VkVideoCodingQualityPresetFlagsKHR; +typedef struct VkQueueFamilyQueryResultStatusProperties2KHR { + VkStructureType sType; + void* pNext; + VkBool32 supported; +} VkQueueFamilyQueryResultStatusProperties2KHR; + typedef struct VkVideoQueueFamilyProperties2KHR { VkStructureType sType; void* pNext; @@ -444,7 +450,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR( #define VK_EXT_video_encode_h264 1 #include "vk_video/vulkan_video_codec_h264std.h" #include "vk_video/vulkan_video_codec_h264std_encode.h" -#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 2 +#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 3 #define VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_EXT_video_encode_h264" typedef enum VkVideoEncodeH264CapabilityFlagBitsEXT { @@ -459,7 +465,6 @@ typedef enum VkVideoEncodeH264CapabilityFlagBitsEXT { VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00000100, VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT = 0x00000200, VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT = 0x00000400, - VK_VIDEO_ENCODE_H264_CAPABILITY_OPTIONAL_RC_EXTENSION_STRUCT_BIT_EXT = 0x00000800, VK_VIDEO_ENCODE_H264_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF } VkVideoEncodeH264CapabilityFlagBitsEXT; typedef VkFlags VkVideoEncodeH264CapabilityFlagsEXT; @@ -587,6 +592,7 @@ typedef struct VkVideoEncodeH264RateControlInfoEXT { uint32_t idrPeriod; uint32_t consecutiveBFrameCount; VkVideoEncodeH264RateControlStructureFlagBitsEXT rateControlStructure; + uint8_t temporalLayerCount; } VkVideoEncodeH264RateControlInfoEXT; typedef struct VkVideoEncodeH264QpEXT { @@ -620,7 +626,7 @@ typedef struct VkVideoEncodeH264RateControlLayerInfoEXT { #define VK_EXT_video_encode_h265 1 #include "vk_video/vulkan_video_codec_h265std.h" #include "vk_video/vulkan_video_codec_h265std_encode.h" -#define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 2 +#define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 3 #define VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME "VK_EXT_video_encode_h265" typedef VkFlags VkVideoEncodeH265CapabilityFlagsEXT; @@ -758,6 +764,7 @@ typedef struct VkVideoEncodeH265RateControlInfoEXT { uint32_t idrPeriod; uint32_t consecutiveBFrameCount; VkVideoEncodeH265RateControlStructureFlagBitsEXT rateControlStructure; + uint8_t subLayerCount; } VkVideoEncodeH265RateControlInfoEXT; typedef struct VkVideoEncodeH265QpEXT { diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h index f6e07ce..8bc98d5 100644 --- a/include/vulkan/vulkan_core.h +++ b/include/vulkan/vulkan_core.h @@ -72,7 +72,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 202 +#define VK_HEADER_VERSION 203 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 2, VK_HEADER_VERSION) @@ -419,6 +419,9 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR = 1000023015, #endif #ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR = 1000023016, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR = 1000024000, #endif VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, @@ -926,6 +929,10 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR = 1000413001, VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR = 1000413002, VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = 1000413003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = 1000425000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = 1000425001, + VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = 1000425002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000, 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, @@ -1962,6 +1969,7 @@ typedef enum VkImageCreateFlagBits { VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000, VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000, + VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = 0x00008000, VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, @@ -8669,6 +8677,7 @@ static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_ #ifdef VK_ENABLE_BETA_EXTENSIONS static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000ULL; #endif +static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 0x4000000000ULL; typedef struct VkFormatProperties3KHR { VkStructureType sType; @@ -13179,6 +13188,46 @@ VKAPI_ATTR void VKAPI_CALL vkSetDeviceMemoryPriorityEXT( #endif +#define VK_QCOM_fragment_density_map_offset 1 +#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 1 +#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_QCOM_fragment_density_map_offset" +typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 fragmentDensityMapOffset; +} VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; + +typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { + VkStructureType sType; + void* pNext; + VkExtent2D fragmentDensityOffsetGranularity; +} VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; + +typedef struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM { + VkStructureType sType; + const void* pNext; + uint32_t fragmentDensityOffsetCount; + const VkOffset2D* pFragmentDensityOffsets; +} VkSubpassFragmentDensityMapOffsetEndInfoQCOM; + + + +#define VK_NV_linear_color_attachment 1 +#define VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION 1 +#define VK_NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME "VK_NV_linear_color_attachment" +typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 linearColorAttachment; +} VkPhysicalDeviceLinearColorAttachmentFeaturesNV; + + + +#define VK_GOOGLE_surfaceless_query 1 +#define VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION 1 +#define VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME "VK_GOOGLE_surfaceless_query" + + #define VK_KHR_acceleration_structure 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR) #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13 diff --git a/include/vulkan/vulkan_enums.hpp b/include/vulkan/vulkan_enums.hpp index 3ce4796..858e437 100644 --- a/include/vulkan/vulkan_enums.hpp +++ b/include/vulkan/vulkan_enums.hpp @@ -336,23 +336,24 @@ namespace VULKAN_HPP_NAMESPACE eDebugMarkerObjectTagInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT, eDebugMarkerMarkerInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT, #if defined( VK_ENABLE_BETA_EXTENSIONS ) - eVideoProfileKHR = VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR, - eVideoCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR, - eVideoPictureResourceKHR = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR, - eVideoGetMemoryPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR, - eVideoBindMemoryKHR = VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR, - eVideoSessionCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR, - eVideoSessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR, - eVideoSessionParametersUpdateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR, - eVideoBeginCodingInfoKHR = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR, - eVideoEndCodingInfoKHR = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR, - eVideoCodingControlInfoKHR = VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR, - eVideoReferenceSlotKHR = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR, - eVideoQueueFamilyProperties2KHR = VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR, - eVideoProfilesKHR = VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR, - ePhysicalDeviceVideoFormatInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR, - eVideoFormatPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR, - eVideoDecodeInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR, + eVideoProfileKHR = VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR, + eVideoCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR, + eVideoPictureResourceKHR = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR, + eVideoGetMemoryPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR, + eVideoBindMemoryKHR = VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR, + eVideoSessionCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR, + eVideoSessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR, + eVideoSessionParametersUpdateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR, + eVideoBeginCodingInfoKHR = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR, + eVideoEndCodingInfoKHR = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR, + eVideoCodingControlInfoKHR = VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR, + eVideoReferenceSlotKHR = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR, + eVideoQueueFamilyProperties2KHR = VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR, + eVideoProfilesKHR = VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR, + ePhysicalDeviceVideoFormatInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR, + eVideoFormatPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR, + eQueueFamilyQueryResultStatusProperties2KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR, + eVideoDecodeInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR, #endif /*VK_ENABLE_BETA_EXTENSIONS*/ eDedicatedAllocationImageCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, eDedicatedAllocationBufferCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, @@ -901,6 +902,13 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceMaintenance4PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR, eDeviceBufferMemoryRequirementsKHR = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR, eDeviceImageMemoryRequirementsKHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR, + ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM, + ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM, + eSubpassFragmentDensityMapOffsetEndInfoQCOM = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM, + ePhysicalDeviceLinearColorAttachmentFeaturesNV = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV, eAttachmentDescription2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR, eAttachmentDescriptionStencilLayoutKHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR, eAttachmentReference2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR, @@ -1266,6 +1274,8 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eVideoProfilesKHR: return "VideoProfilesKHR"; case StructureType::ePhysicalDeviceVideoFormatInfoKHR: return "PhysicalDeviceVideoFormatInfoKHR"; case StructureType::eVideoFormatPropertiesKHR: return "VideoFormatPropertiesKHR"; + case StructureType::eQueueFamilyQueryResultStatusProperties2KHR: + return "QueueFamilyQueryResultStatusProperties2KHR"; case StructureType::eVideoDecodeInfoKHR: return "VideoDecodeInfoKHR"; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ case StructureType::eDedicatedAllocationImageCreateInfoNV: return "DedicatedAllocationImageCreateInfoNV"; @@ -1874,6 +1884,14 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceMaintenance4PropertiesKHR: return "PhysicalDeviceMaintenance4PropertiesKHR"; case StructureType::eDeviceBufferMemoryRequirementsKHR: return "DeviceBufferMemoryRequirementsKHR"; case StructureType::eDeviceImageMemoryRequirementsKHR: return "DeviceImageMemoryRequirementsKHR"; + case StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM: + return "PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM"; + case StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM: + return "PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM"; + case StructureType::eSubpassFragmentDensityMapOffsetEndInfoQCOM: + return "SubpassFragmentDensityMapOffsetEndInfoQCOM"; + case StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV: + return "PhysicalDeviceLinearColorAttachmentFeaturesNV"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -2691,6 +2709,7 @@ namespace VULKAN_HPP_NAMESPACE eCornerSampledNV = VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV, eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT, eSubsampledEXT = VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT, + eFragmentDensityMapOffsetQCOM = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM, e2DArrayCompatibleKHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR, eAliasKHR = VK_IMAGE_CREATE_ALIAS_BIT_KHR, eBlockTexelViewCompatibleKHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR, @@ -2718,6 +2737,7 @@ namespace VULKAN_HPP_NAMESPACE case ImageCreateFlagBits::eCornerSampledNV: return "CornerSampledNV"; case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT: return "SampleLocationsCompatibleDepthEXT"; case ImageCreateFlagBits::eSubsampledEXT: return "SubsampledEXT"; + case ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM: return "FragmentDensityMapOffsetQCOM"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -6006,8 +6026,7 @@ namespace VULKAN_HPP_NAMESPACE eDeblockingFilterEnabled = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT, eDeblockingFilterPartial = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT, eMultipleSlicePerFrame = VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT, - eEvenlyDistributedSliceSize = VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT, - eOptionalRcExtensionStruct = VK_VIDEO_ENCODE_H264_CAPABILITY_OPTIONAL_RC_EXTENSION_STRUCT_BIT_EXT + eEvenlyDistributedSliceSize = VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT }; VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilityFlagBitsEXT value ) @@ -6025,7 +6044,6 @@ namespace VULKAN_HPP_NAMESPACE case VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial: return "DeblockingFilterPartial"; case VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame: return "MultipleSlicePerFrame"; case VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize: return "EvenlyDistributedSliceSize"; - case VideoEncodeH264CapabilityFlagBitsEXT::eOptionalRcExtensionStruct: return "OptionalRcExtensionStruct"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -8230,8 +8248,9 @@ namespace VULKAN_HPP_NAMESPACE eFragmentShadingRateAttachment = VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, #if defined( VK_ENABLE_BETA_EXTENSIONS ) eVideoEncodeInput = VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR, - eVideoEncodeDpb = VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR + eVideoEncodeDpb = VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR, #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + eLinearColorAttachmentNV = VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV }; VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlagBits2KHR value ) @@ -8280,6 +8299,7 @@ namespace VULKAN_HPP_NAMESPACE case FormatFeatureFlagBits2KHR::eVideoEncodeInput: return "VideoEncodeInput"; case FormatFeatureFlagBits2KHR::eVideoEncodeDpb: return "VideoEncodeDpb"; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + case FormatFeatureFlagBits2KHR::eLinearColorAttachmentNV: return "LinearColorAttachmentNV"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -8495,8 +8515,8 @@ namespace VULKAN_HPP_NAMESPACE case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8SrgbBlock: return 8; case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8A1UnormBlock: return 8; case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8A1SrgbBlock: return 8; - case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8A8UnormBlock: return 8; - case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8A8SrgbBlock: return 8; + case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8A8UnormBlock: return 16; + case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8A8SrgbBlock: return 16; case VULKAN_HPP_NAMESPACE::Format::eEacR11UnormBlock: return 8; case VULKAN_HPP_NAMESPACE::Format::eEacR11SnormBlock: return 8; case VULKAN_HPP_NAMESPACE::Format::eEacR11G11UnormBlock: return 16; @@ -11820,16 +11840,16 @@ namespace VULKAN_HPP_NAMESPACE { enum : VkFlags { - allFlags = VkFlags( ImageCreateFlagBits::eSparseBinding ) | VkFlags( ImageCreateFlagBits::eSparseResidency ) | - VkFlags( ImageCreateFlagBits::eSparseAliased ) | VkFlags( ImageCreateFlagBits::eMutableFormat ) | - VkFlags( ImageCreateFlagBits::eCubeCompatible ) | VkFlags( ImageCreateFlagBits::eAlias ) | - VkFlags( ImageCreateFlagBits::eSplitInstanceBindRegions ) | - VkFlags( ImageCreateFlagBits::e2DArrayCompatible ) | - VkFlags( ImageCreateFlagBits::eBlockTexelViewCompatible ) | - VkFlags( ImageCreateFlagBits::eExtendedUsage ) | VkFlags( ImageCreateFlagBits::eProtected ) | - VkFlags( ImageCreateFlagBits::eDisjoint ) | VkFlags( ImageCreateFlagBits::eCornerSampledNV ) | - VkFlags( ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT ) | - VkFlags( ImageCreateFlagBits::eSubsampledEXT ) + allFlags = + VkFlags( ImageCreateFlagBits::eSparseBinding ) | VkFlags( ImageCreateFlagBits::eSparseResidency ) | + VkFlags( ImageCreateFlagBits::eSparseAliased ) | VkFlags( ImageCreateFlagBits::eMutableFormat ) | + VkFlags( ImageCreateFlagBits::eCubeCompatible ) | VkFlags( ImageCreateFlagBits::eAlias ) | + VkFlags( ImageCreateFlagBits::eSplitInstanceBindRegions ) | VkFlags( ImageCreateFlagBits::e2DArrayCompatible ) | + VkFlags( ImageCreateFlagBits::eBlockTexelViewCompatible ) | VkFlags( ImageCreateFlagBits::eExtendedUsage ) | + VkFlags( ImageCreateFlagBits::eProtected ) | VkFlags( ImageCreateFlagBits::eDisjoint ) | + VkFlags( ImageCreateFlagBits::eCornerSampledNV ) | + VkFlags( ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT ) | + VkFlags( ImageCreateFlagBits::eSubsampledEXT ) | VkFlags( ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM ) }; }; @@ -11892,6 +11912,8 @@ namespace VULKAN_HPP_NAMESPACE result += "SampleLocationsCompatibleDepthEXT | "; if ( value & ImageCreateFlagBits::eSubsampledEXT ) result += "SubsampledEXT | "; + if ( value & ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM ) + result += "FragmentDensityMapOffsetQCOM | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -16153,8 +16175,7 @@ namespace VULKAN_HPP_NAMESPACE VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame ) | - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize ) | - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eOptionalRcExtensionStruct ) + VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize ) }; }; @@ -16210,8 +16231,6 @@ namespace VULKAN_HPP_NAMESPACE result += "MultipleSlicePerFrame | "; if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize ) result += "EvenlyDistributedSliceSize | "; - if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eOptionalRcExtensionStruct ) - result += "OptionalRcExtensionStruct | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -18423,6 +18442,7 @@ namespace VULKAN_HPP_NAMESPACE | VkFlags64( FormatFeatureFlagBits2KHR::eVideoEncodeInput ) | VkFlags64( FormatFeatureFlagBits2KHR::eVideoEncodeDpb ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + | VkFlags64( FormatFeatureFlagBits2KHR::eLinearColorAttachmentNV ) }; }; @@ -18528,6 +18548,8 @@ namespace VULKAN_HPP_NAMESPACE if ( value & FormatFeatureFlagBits2KHR::eVideoEncodeDpb ) result += "VideoEncodeDpb | "; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + if ( value & FormatFeatureFlagBits2KHR::eLinearColorAttachmentNV ) + result += "LinearColorAttachmentNV | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } diff --git a/include/vulkan/vulkan_handles.hpp b/include/vulkan/vulkan_handles.hpp index b3aa99c..741f759 100644 --- a/include/vulkan/vulkan_handles.hpp +++ b/include/vulkan/vulkan_handles.hpp @@ -427,6 +427,7 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_KHR_video_queue === + struct QueueFamilyQueryResultStatusProperties2KHR; struct VideoQueueFamilyProperties2KHR; struct VideoProfileKHR; struct VideoProfilesKHR; @@ -1312,6 +1313,14 @@ namespace VULKAN_HPP_NAMESPACE struct DeviceBufferMemoryRequirementsKHR; struct DeviceImageMemoryRequirementsKHR; + //=== VK_QCOM_fragment_density_map_offset === + struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; + struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; + struct SubpassFragmentDensityMapOffsetEndInfoQCOM; + + //=== VK_NV_linear_color_attachment === + struct PhysicalDeviceLinearColorAttachmentFeaturesNV; + //=============== //=== HANDLEs === //=============== @@ -12596,8 +12605,8 @@ namespace VULKAN_HPP_NAMESPACE template , typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template , typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = SurfaceFormatKHRAllocator, @@ -12618,8 +12627,8 @@ namespace VULKAN_HPP_NAMESPACE template , typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template , typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B = PresentModeKHRAllocator, @@ -14531,476 +14540,4 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ } // namespace VULKAN_HPP_NAMESPACE - -namespace std -{ - //======================= - //=== HASH structures === - //======================= - - //=== VK_VERSION_1_0 === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Instance const & instance ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( instance ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice const & physicalDevice ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( physicalDevice ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Device const & device ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( device ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Queue const & queue ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( queue ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemory const & deviceMemory ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( deviceMemory ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Fence const & fence ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( fence ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Semaphore const & semaphore ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( semaphore ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( event ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPool const & queryPool ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( queryPool ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Buffer const & buffer ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( buffer ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( bufferView ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Image const & image ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( image ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageView const & imageView ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( imageView ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModule const & shaderModule ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( shaderModule ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCache const & pipelineCache ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( pipelineCache ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Pipeline const & pipeline ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( pipeline ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayout const & pipelineLayout ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( pipelineLayout ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Sampler const & sampler ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( sampler ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPool const & descriptorPool ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( descriptorPool ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSet const & descriptorSet ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( descriptorSet ) ); - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & descriptorSetLayout ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( descriptorSetLayout ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Framebuffer const & framebuffer ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( framebuffer ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPass const & renderPass ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( renderPass ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( commandPool ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( commandBuffer ) ); - } - }; - - //=== VK_VERSION_1_1 === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const - VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( samplerYcbcrConversion ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & descriptorUpdateTemplate ) const - VULKAN_HPP_NOEXCEPT - { - return std::hash{}( - static_cast( descriptorUpdateTemplate ) ); - } - }; - - //=== VK_KHR_surface === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceKHR const & surfaceKHR ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( surfaceKHR ) ); - } - }; - - //=== VK_KHR_swapchain === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainKHR const & swapchainKHR ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( swapchainKHR ) ); - } - }; - - //=== VK_KHR_display === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayKHR const & displayKHR ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( displayKHR ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeKHR const & displayModeKHR ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( displayModeKHR ) ); - } - }; - - //=== VK_EXT_debug_report === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & debugReportCallbackEXT ) const - VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( debugReportCallbackEXT ) ); - } - }; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_KHR_video_queue === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionKHR const & videoSessionKHR ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( videoSessionKHR ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & videoSessionParametersKHR ) const - VULKAN_HPP_NOEXCEPT - { - return std::hash{}( - static_cast( videoSessionParametersKHR ) ); - } - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_NVX_binary_import === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleNVX const & cuModuleNVX ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( cuModuleNVX ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionNVX const & cuFunctionNVX ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( cuFunctionNVX ) ); - } - }; - - //=== VK_EXT_debug_utils === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & debugUtilsMessengerEXT ) const - VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( debugUtilsMessengerEXT ) ); - } - }; - - //=== VK_KHR_acceleration_structure === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & accelerationStructureKHR ) const - VULKAN_HPP_NOEXCEPT - { - return std::hash{}( - static_cast( accelerationStructureKHR ) ); - } - }; - - //=== VK_EXT_validation_cache === - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & validationCacheEXT ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( validationCacheEXT ) ); - } - }; - - //=== VK_NV_ray_tracing === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & accelerationStructureNV ) const - VULKAN_HPP_NOEXCEPT - { - return std::hash{}( - static_cast( accelerationStructureNV ) ); - } - }; - - //=== VK_INTEL_performance_query === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & performanceConfigurationINTEL ) - const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( - static_cast( performanceConfigurationINTEL ) ); - } - }; - - //=== VK_KHR_deferred_host_operations === - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & deferredOperationKHR ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( deferredOperationKHR ) ); - } - }; - - //=== VK_NV_device_generated_commands === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & indirectCommandsLayoutNV ) const - VULKAN_HPP_NOEXCEPT - { - return std::hash{}( - static_cast( indirectCommandsLayoutNV ) ); - } - }; - - //=== VK_EXT_private_data === - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT const & privateDataSlotEXT ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( privateDataSlotEXT ) ); - } - }; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & bufferCollectionFUCHSIA ) const - VULKAN_HPP_NOEXCEPT - { - return std::hash{}( - static_cast( bufferCollectionFUCHSIA ) ); - } - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -} // namespace std #endif diff --git a/include/vulkan/vulkan_raii.hpp b/include/vulkan/vulkan_raii.hpp index f5827b9..5562fe9 100644 --- a/include/vulkan/vulkan_raii.hpp +++ b/include/vulkan/vulkan_raii.hpp @@ -2762,10 +2762,10 @@ namespace VULKAN_HPP_NAMESPACE getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; VULKAN_HPP_NODISCARD std::vector - getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; + getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; - VULKAN_HPP_NODISCARD std::vector - getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; + VULKAN_HPP_NODISCARD std::vector getSurfacePresentModesKHR( + VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; //=== VK_KHR_swapchain === diff --git a/include/vulkan/vulkan_structs.hpp b/include/vulkan/vulkan_structs.hpp index 48d6e24..bc87d15 100644 --- a/include/vulkan/vulkan_structs.hpp +++ b/include/vulkan/vulkan_structs.hpp @@ -86,28 +86,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAabbPositionsKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAabbPositionsKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAabbPositionsKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkAabbPositionsKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( minX, minY, minZ, maxX, maxY, maxZ ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AabbPositionsKHR const & ) const = default; #else bool operator==( AabbPositionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( minX == rhs.minX ) && ( minY == rhs.minY ) && ( minZ == rhs.minZ ) && ( maxX == rhs.maxX ) && - ( maxY == rhs.maxY ) && ( maxZ == rhs.maxZ ); + return this->reflect() == rhs.reflect(); } bool operator!=( AabbPositionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -127,26 +136,6 @@ namespace VULKAN_HPP_NAMESPACE "AabbPositionsKHR is not nothrow_move_constructible!" ); using AabbPositionsNV = AabbPositionsKHR; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AabbPositionsKHR const & aabbPositionsKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.minX ); - VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.minY ); - VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.minZ ); - VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.maxX ); - VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.maxY ); - VULKAN_HPP_HASH_COMBINE( float, seed, aabbPositionsKHR.maxZ ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ union DeviceOrHostAddressConstKHR { using NativeType = VkDeviceOrHostAddressConstKHR; @@ -189,8 +178,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress; const void * hostAddress; #else - VkDeviceAddress deviceAddress; - const void * hostAddress; + VkDeviceAddress deviceAddress; + const void * hostAddress; #endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ }; @@ -298,16 +287,35 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureGeometryTrianglesDataKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureGeometryTrianglesDataKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureGeometryTrianglesDataKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureGeometryTrianglesDataKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, vertexFormat, vertexData, vertexStride, maxVertex, indexType, indexData, transformData ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryTrianglesDataKHR; const void * pNext = {}; @@ -394,16 +402,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureGeometryAabbsDataKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureGeometryAabbsDataKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureGeometryAabbsDataKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureGeometryAabbsDataKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, data, stride ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryAabbsDataKHR; const void * pNext = {}; @@ -485,16 +506,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureGeometryInstancesDataKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureGeometryInstancesDataKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureGeometryInstancesDataKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureGeometryInstancesDataKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, arrayOfPointers, data ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryInstancesDataKHR; const void * pNext = {}; @@ -645,16 +679,30 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureGeometryKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureGeometryKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureGeometryKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureGeometryKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, geometryType, geometry, flags ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryKHR; const void * pNext = {}; @@ -718,8 +766,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress; void * hostAddress; #else - VkDeviceAddress deviceAddress; - void * hostAddress; + VkDeviceAddress deviceAddress; + void * hostAddress; #endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ }; @@ -904,16 +952,46 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureBuildGeometryInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureBuildGeometryInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureBuildGeometryInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureBuildGeometryInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + type, + flags, + mode, + srcAccelerationStructure, + dstAccelerationStructure, + geometryCount, + pGeometries, + ppGeometries, + scratchData ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureBuildGeometryInfoKHR; const void * pNext = {}; @@ -1009,28 +1087,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureBuildRangeInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureBuildRangeInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureBuildRangeInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureBuildRangeInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( primitiveCount, primitiveOffset, firstVertex, transformOffset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureBuildRangeInfoKHR const & ) const = default; #else bool operator==( AccelerationStructureBuildRangeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( primitiveCount == rhs.primitiveCount ) && ( primitiveOffset == rhs.primitiveOffset ) && - ( firstVertex == rhs.firstVertex ) && ( transformOffset == rhs.transformOffset ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureBuildRangeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -1050,25 +1137,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "AccelerationStructureBuildRangeInfoKHR is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR const & - accelerationStructureBuildRangeInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureBuildRangeInfoKHR.primitiveCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureBuildRangeInfoKHR.primitiveOffset ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureBuildRangeInfoKHR.firstVertex ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureBuildRangeInfoKHR.transformOffset ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AccelerationStructureBuildSizesInfoKHR { using NativeType = VkAccelerationStructureBuildSizesInfoKHR; @@ -1135,29 +1203,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureBuildSizesInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureBuildSizesInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureBuildSizesInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureBuildSizesInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, accelerationStructureSize, updateScratchSize, buildScratchSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureBuildSizesInfoKHR const & ) const = default; #else bool operator==( AccelerationStructureBuildSizesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( accelerationStructureSize == rhs.accelerationStructureSize ) && - ( updateScratchSize == rhs.updateScratchSize ) && ( buildScratchSize == rhs.buildScratchSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureBuildSizesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -1184,29 +1264,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = AccelerationStructureBuildSizesInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR const & - accelerationStructureBuildSizesInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureBuildSizesInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureBuildSizesInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureBuildSizesInfoKHR.accelerationStructureSize ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureBuildSizesInfoKHR.updateScratchSize ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureBuildSizesInfoKHR.buildScratchSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AccelerationStructureCreateInfoKHR { using NativeType = VkAccelerationStructureCreateInfoKHR; @@ -1300,29 +1357,44 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, createFlags, buffer, offset, size, type, deviceAddress ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureCreateInfoKHR const & ) const = default; #else bool operator==( AccelerationStructureCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createFlags == rhs.createFlags ) && - ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( size == rhs.size ) && ( type == rhs.type ) && - ( deviceAddress == rhs.deviceAddress ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -1352,32 +1424,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = AccelerationStructureCreateInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & - accelerationStructureCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::AccelerationStructureCreateFlagsKHR, seed, accelerationStructureCreateInfoKHR.createFlags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, accelerationStructureCreateInfoKHR.buffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureCreateInfoKHR.offset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureCreateInfoKHR.size ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR, seed, accelerationStructureCreateInfoKHR.type ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceAddress, seed, accelerationStructureCreateInfoKHR.deviceAddress ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct GeometryTrianglesNV { using NativeType = VkGeometryTrianglesNV; @@ -1509,32 +1555,61 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkGeometryTrianglesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkGeometryTrianglesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkGeometryTrianglesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkGeometryTrianglesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + vertexData, + vertexOffset, + vertexCount, + vertexStride, + vertexFormat, + indexData, + indexOffset, + indexCount, + indexType, + transformData, + transformOffset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GeometryTrianglesNV const & ) const = default; #else bool operator==( GeometryTrianglesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexData == rhs.vertexData ) && - ( vertexOffset == rhs.vertexOffset ) && ( vertexCount == rhs.vertexCount ) && - ( vertexStride == rhs.vertexStride ) && ( vertexFormat == rhs.vertexFormat ) && - ( indexData == rhs.indexData ) && ( indexOffset == rhs.indexOffset ) && ( indexCount == rhs.indexCount ) && - ( indexType == rhs.indexType ) && ( transformData == rhs.transformData ) && - ( transformOffset == rhs.transformOffset ); + return this->reflect() == rhs.reflect(); } bool operator!=( GeometryTrianglesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -1566,34 +1641,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = GeometryTrianglesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const & geometryTrianglesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, geometryTrianglesNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, geometryTrianglesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, geometryTrianglesNV.vertexData ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryTrianglesNV.vertexOffset ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, geometryTrianglesNV.vertexCount ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryTrianglesNV.vertexStride ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, geometryTrianglesNV.vertexFormat ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, geometryTrianglesNV.indexData ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryTrianglesNV.indexOffset ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, geometryTrianglesNV.indexCount ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::IndexType, seed, geometryTrianglesNV.indexType ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, geometryTrianglesNV.transformData ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryTrianglesNV.transformOffset ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct GeometryAABBNV { using NativeType = VkGeometryAABBNV; @@ -1659,28 +1706,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkGeometryAABBNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkGeometryAABBNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkGeometryAABBNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkGeometryAABBNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, aabbData, numAABBs, stride, offset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GeometryAABBNV const & ) const = default; #else bool operator==( GeometryAABBNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aabbData == rhs.aabbData ) && - ( numAABBs == rhs.numAABBs ) && ( stride == rhs.stride ) && ( offset == rhs.offset ); + return this->reflect() == rhs.reflect(); } bool operator!=( GeometryAABBNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -1705,26 +1766,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = GeometryAABBNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryAABBNV const & geometryAABBNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, geometryAABBNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, geometryAABBNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, geometryAABBNV.aabbData ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, geometryAABBNV.numAABBs ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, geometryAABBNV.stride ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, geometryAABBNV.offset ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct GeometryDataNV { using NativeType = VkGeometryDataNV; @@ -1767,27 +1808,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkGeometryDataNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkGeometryDataNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkGeometryDataNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkGeometryDataNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( triangles, aabbs ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GeometryDataNV const & ) const = default; #else bool operator==( GeometryDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( triangles == rhs.triangles ) && ( aabbs == rhs.aabbs ); + return this->reflect() == rhs.reflect(); } bool operator!=( GeometryDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -1802,22 +1853,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "GeometryDataNV is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryDataNV const & geometryDataNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV, seed, geometryDataNV.triangles ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryAABBNV, seed, geometryDataNV.aabbs ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct GeometryNV { using NativeType = VkGeometryNV; @@ -1878,28 +1913,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkGeometryNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkGeometryNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkGeometryNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkGeometryNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, geometryType, geometry, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GeometryNV const & ) const = default; #else bool operator==( GeometryNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( geometryType == rhs.geometryType ) && - ( geometry == rhs.geometry ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( GeometryNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -1923,25 +1971,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = GeometryNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryNV const & geometryNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, geometryNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, geometryNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryTypeKHR, seed, geometryNV.geometryType ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryDataNV, seed, geometryNV.geometry ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::GeometryFlagsKHR, seed, geometryNV.flags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AccelerationStructureInfoNV { using NativeType = VkAccelerationStructureInfoNV; @@ -2047,29 +2076,43 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type, flags, instanceCount, geometryCount, pGeometries ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureInfoNV const & ) const = default; #else bool operator==( AccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( flags == rhs.flags ) && - ( instanceCount == rhs.instanceCount ) && ( geometryCount == rhs.geometryCount ) && - ( pGeometries == rhs.pGeometries ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -2097,30 +2140,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = AccelerationStructureInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const & accelerationStructureInfoNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::AccelerationStructureTypeNV, seed, accelerationStructureInfoNV.type ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagsNV, seed, accelerationStructureInfoNV.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInfoNV.instanceCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInfoNV.geometryCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::GeometryNV *, seed, accelerationStructureInfoNV.pGeometries ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AccelerationStructureCreateInfoNV { using NativeType = VkAccelerationStructureCreateInfoNV; @@ -2176,28 +2195,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, compactedSize, info ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureCreateInfoNV const & ) const = default; #else bool operator==( AccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compactedSize == rhs.compactedSize ) && - ( info == rhs.info ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -2222,26 +2253,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = AccelerationStructureCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & - accelerationStructureCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, accelerationStructureCreateInfoNV.compactedSize ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV, seed, accelerationStructureCreateInfoNV.info ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AccelerationStructureDeviceAddressInfoKHR { using NativeType = VkAccelerationStructureDeviceAddressInfoKHR; @@ -2292,27 +2303,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureDeviceAddressInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureDeviceAddressInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureDeviceAddressInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureDeviceAddressInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, accelerationStructure ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureDeviceAddressInfoKHR const & ) const = default; #else bool operator==( AccelerationStructureDeviceAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureDeviceAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -2337,27 +2360,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = AccelerationStructureDeviceAddressInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR const & - accelerationStructureDeviceAddressInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureDeviceAddressInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureDeviceAddressInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, - seed, - accelerationStructureDeviceAddressInfoKHR.accelerationStructure ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AccelerationStructureGeometryMotionTrianglesDataNV { using NativeType = VkAccelerationStructureGeometryMotionTrianglesDataNV; @@ -2409,16 +2411,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureGeometryMotionTrianglesDataNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureGeometryMotionTrianglesDataNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureGeometryMotionTrianglesDataNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureGeometryMotionTrianglesDataNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vertexData ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV; const void * pNext = {}; @@ -2474,27 +2488,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkTransformMatrixKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkTransformMatrixKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkTransformMatrixKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkTransformMatrixKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( matrix ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( TransformMatrixKHR const & ) const = default; #else bool operator==( TransformMatrixKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( matrix == rhs.matrix ); + return this->reflect() == rhs.reflect(); } bool operator!=( TransformMatrixKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -2509,28 +2533,6 @@ namespace VULKAN_HPP_NAMESPACE "TransformMatrixKHR is not nothrow_move_constructible!" ); using TransformMatrixNV = TransformMatrixKHR; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transformMatrixKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - for ( size_t i = 0; i < 3; ++i ) - { - for ( size_t j = 0; j < 4; ++j ) - { - VULKAN_HPP_HASH_COMBINE( float, seed, transformMatrixKHR.matrix[i][j] ); - } - } - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AccelerationStructureInstanceKHR { using NativeType = VkAccelerationStructureInstanceKHR; @@ -2611,30 +2613,47 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureInstanceKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureInstanceKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureInstanceKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureInstanceKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( transform, + instanceCustomIndex, + mask, + instanceShaderBindingTableRecordOffset, + flags, + accelerationStructureReference ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureInstanceKHR const & ) const = default; #else bool operator==( AccelerationStructureInstanceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( transform == rhs.transform ) && ( instanceCustomIndex == rhs.instanceCustomIndex ) && - ( mask == rhs.mask ) && - ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) && - ( flags == rhs.flags ) && ( accelerationStructureReference == rhs.accelerationStructureReference ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureInstanceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -2656,29 +2675,6 @@ namespace VULKAN_HPP_NAMESPACE "AccelerationStructureInstanceKHR is not nothrow_move_constructible!" ); using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR const & accelerationStructureInstanceKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::TransformMatrixKHR, seed, accelerationStructureInstanceKHR.transform ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInstanceKHR.instanceCustomIndex ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInstanceKHR.mask ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureInstanceKHR.instanceShaderBindingTableRecordOffset ); - VULKAN_HPP_HASH_COMBINE( VkGeometryInstanceFlagsKHR, seed, accelerationStructureInstanceKHR.flags ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, accelerationStructureInstanceKHR.accelerationStructureReference ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AccelerationStructureMatrixMotionInstanceNV { using NativeType = VkAccelerationStructureMatrixMotionInstanceNV; @@ -2771,30 +2767,49 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureMatrixMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureMatrixMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureMatrixMotionInstanceNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureMatrixMotionInstanceNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( transformT0, + transformT1, + instanceCustomIndex, + mask, + instanceShaderBindingTableRecordOffset, + flags, + accelerationStructureReference ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureMatrixMotionInstanceNV const & ) const = default; #else bool operator==( AccelerationStructureMatrixMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( transformT0 == rhs.transformT0 ) && ( transformT1 == rhs.transformT1 ) && - ( instanceCustomIndex == rhs.instanceCustomIndex ) && ( mask == rhs.mask ) && - ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) && - ( flags == rhs.flags ) && ( accelerationStructureReference == rhs.accelerationStructureReference ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureMatrixMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -2817,32 +2832,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "AccelerationStructureMatrixMotionInstanceNV is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV const & - accelerationStructureMatrixMotionInstanceNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::TransformMatrixKHR, seed, accelerationStructureMatrixMotionInstanceNV.transformT0 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::TransformMatrixKHR, seed, accelerationStructureMatrixMotionInstanceNV.transformT1 ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureMatrixMotionInstanceNV.instanceCustomIndex ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureMatrixMotionInstanceNV.mask ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, accelerationStructureMatrixMotionInstanceNV.instanceShaderBindingTableRecordOffset ); - VULKAN_HPP_HASH_COMBINE( VkGeometryInstanceFlagsKHR, seed, accelerationStructureMatrixMotionInstanceNV.flags ); - VULKAN_HPP_HASH_COMBINE( - uint64_t, seed, accelerationStructureMatrixMotionInstanceNV.accelerationStructureReference ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AccelerationStructureMemoryRequirementsInfoNV { using NativeType = VkAccelerationStructureMemoryRequirementsInfoNV; @@ -2903,28 +2892,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureMemoryRequirementsInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureMemoryRequirementsInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type, accelerationStructure ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureMemoryRequirementsInfoNV const & ) const = default; #else bool operator==( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && - ( accelerationStructure == rhs.accelerationStructure ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -2951,30 +2952,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = AccelerationStructureMemoryRequirementsInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV const & - accelerationStructureMemoryRequirementsInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureMemoryRequirementsInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureMemoryRequirementsInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeNV, - seed, - accelerationStructureMemoryRequirementsInfoNV.type ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccelerationStructureNV, - seed, - accelerationStructureMemoryRequirementsInfoNV.accelerationStructure ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AccelerationStructureMotionInfoNV { using NativeType = VkAccelerationStructureMotionInfoNV; @@ -3030,28 +3007,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureMotionInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureMotionInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureMotionInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureMotionInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxInstances, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureMotionInfoNV const & ) const = default; #else bool operator==( AccelerationStructureMotionInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxInstances == rhs.maxInstances ) && - ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureMotionInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -3076,26 +3065,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = AccelerationStructureMotionInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV const & - accelerationStructureMotionInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureMotionInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureMotionInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureMotionInfoNV.maxInstances ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoFlagsNV, seed, accelerationStructureMotionInfoNV.flags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SRTDataNV { using NativeType = VkSRTDataNV; @@ -3247,30 +3216,52 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSRTDataNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSRTDataNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSRTDataNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkSRTDataNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sx, a, b, pvx, sy, c, pvy, sz, pvz, qx, qy, qz, qw, tx, ty, tz ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SRTDataNV const & ) const = default; #else bool operator==( SRTDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sx == rhs.sx ) && ( a == rhs.a ) && ( b == rhs.b ) && ( pvx == rhs.pvx ) && ( sy == rhs.sy ) && - ( c == rhs.c ) && ( pvy == rhs.pvy ) && ( sz == rhs.sz ) && ( pvz == rhs.pvz ) && ( qx == rhs.qx ) && - ( qy == rhs.qy ) && ( qz == rhs.qz ) && ( qw == rhs.qw ) && ( tx == rhs.tx ) && ( ty == rhs.ty ) && - ( tz == rhs.tz ); + return this->reflect() == rhs.reflect(); } bool operator!=( SRTDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -3299,36 +3290,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SRTDataNV is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SRTDataNV const & sRTDataNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.sx ); - VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.a ); - VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.b ); - VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.pvx ); - VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.sy ); - VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.c ); - VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.pvy ); - VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.sz ); - VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.pvz ); - VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.qx ); - VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.qy ); - VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.qz ); - VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.qw ); - VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.tx ); - VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.ty ); - VULKAN_HPP_HASH_COMBINE( float, seed, sRTDataNV.tz ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AccelerationStructureSRTMotionInstanceNV { using NativeType = VkAccelerationStructureSRTMotionInstanceNV; @@ -3421,30 +3382,49 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureSRTMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureSRTMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureSRTMotionInstanceNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureSRTMotionInstanceNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( transformT0, + transformT1, + instanceCustomIndex, + mask, + instanceShaderBindingTableRecordOffset, + flags, + accelerationStructureReference ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureSRTMotionInstanceNV const & ) const = default; #else bool operator==( AccelerationStructureSRTMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( transformT0 == rhs.transformT0 ) && ( transformT1 == rhs.transformT1 ) && - ( instanceCustomIndex == rhs.instanceCustomIndex ) && ( mask == rhs.mask ) && - ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) && - ( flags == rhs.flags ) && ( accelerationStructureReference == rhs.accelerationStructureReference ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureSRTMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -3467,31 +3447,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "AccelerationStructureSRTMotionInstanceNV is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV const & - accelerationStructureSRTMotionInstanceNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SRTDataNV, seed, accelerationStructureSRTMotionInstanceNV.transformT0 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SRTDataNV, seed, accelerationStructureSRTMotionInstanceNV.transformT1 ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureSRTMotionInstanceNV.instanceCustomIndex ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, accelerationStructureSRTMotionInstanceNV.mask ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, accelerationStructureSRTMotionInstanceNV.instanceShaderBindingTableRecordOffset ); - VULKAN_HPP_HASH_COMBINE( VkGeometryInstanceFlagsKHR, seed, accelerationStructureSRTMotionInstanceNV.flags ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, accelerationStructureSRTMotionInstanceNV.accelerationStructureReference ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ union AccelerationStructureMotionInstanceDataNV { using NativeType = VkAccelerationStructureMotionInstanceDataNV; @@ -3615,16 +3570,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureMotionInstanceNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureMotionInstanceNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( type, flags, data ); + } + public: VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceTypeNV type = VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceTypeNV::eStatic; @@ -3686,27 +3653,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAccelerationStructureVersionInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureVersionInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAccelerationStructureVersionInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkAccelerationStructureVersionInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pVersionData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureVersionInfoKHR const & ) const = default; #else bool operator==( AccelerationStructureVersionInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pVersionData == rhs.pVersionData ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureVersionInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -3730,24 +3707,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = AccelerationStructureVersionInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR const & - accelerationStructureVersionInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, accelerationStructureVersionInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, accelerationStructureVersionInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( const uint8_t *, seed, accelerationStructureVersionInfoKHR.pVersionData ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AcquireNextImageInfoKHR { using NativeType = VkAcquireNextImageInfoKHR; @@ -3823,29 +3782,43 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAcquireNextImageInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAcquireNextImageInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAcquireNextImageInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkAcquireNextImageInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchain, timeout, semaphore, fence, deviceMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AcquireNextImageInfoKHR const & ) const = default; #else bool operator==( AcquireNextImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && - ( timeout == rhs.timeout ) && ( semaphore == rhs.semaphore ) && ( fence == rhs.fence ) && - ( deviceMask == rhs.deviceMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( AcquireNextImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -3872,28 +3845,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = AcquireNextImageInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR const & acquireNextImageInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, acquireNextImageInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, acquireNextImageInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainKHR, seed, acquireNextImageInfoKHR.swapchain ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, acquireNextImageInfoKHR.timeout ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, acquireNextImageInfoKHR.semaphore ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, acquireNextImageInfoKHR.fence ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, acquireNextImageInfoKHR.deviceMask ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AcquireProfilingLockInfoKHR { using NativeType = VkAcquireProfilingLockInfoKHR; @@ -3945,27 +3896,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAcquireProfilingLockInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAcquireProfilingLockInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAcquireProfilingLockInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkAcquireProfilingLockInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, timeout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AcquireProfilingLockInfoKHR const & ) const = default; #else bool operator==( AcquireProfilingLockInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( timeout == rhs.timeout ); + return this->reflect() == rhs.reflect(); } bool operator!=( AcquireProfilingLockInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -3990,26 +3954,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = AcquireProfilingLockInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR const & acquireProfilingLockInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, acquireProfilingLockInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, acquireProfilingLockInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::AcquireProfilingLockFlagsKHR, seed, acquireProfilingLockInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, acquireProfilingLockInfoKHR.timeout ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AllocationCallbacks { using NativeType = VkAllocationCallbacks; @@ -4086,29 +4030,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAllocationCallbacks const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAllocationCallbacks const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAllocationCallbacks &() VULKAN_HPP_NOEXCEPT + explicit operator VkAllocationCallbacks &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( pUserData, pfnAllocation, pfnReallocation, pfnFree, pfnInternalAllocation, pfnInternalFree ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AllocationCallbacks const & ) const = default; #else bool operator==( AllocationCallbacks const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( pUserData == rhs.pUserData ) && ( pfnAllocation == rhs.pfnAllocation ) && - ( pfnReallocation == rhs.pfnReallocation ) && ( pfnFree == rhs.pfnFree ) && - ( pfnInternalAllocation == rhs.pfnInternalAllocation ) && ( pfnInternalFree == rhs.pfnInternalFree ); + return this->reflect() == rhs.reflect(); } bool operator!=( AllocationCallbacks const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -4127,27 +4084,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "AllocationCallbacks is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::AllocationCallbacks const & allocationCallbacks ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( void *, seed, allocationCallbacks.pUserData ); - VULKAN_HPP_HASH_COMBINE( PFN_vkAllocationFunction, seed, allocationCallbacks.pfnAllocation ); - VULKAN_HPP_HASH_COMBINE( PFN_vkReallocationFunction, seed, allocationCallbacks.pfnReallocation ); - VULKAN_HPP_HASH_COMBINE( PFN_vkFreeFunction, seed, allocationCallbacks.pfnFree ); - VULKAN_HPP_HASH_COMBINE( PFN_vkInternalAllocationNotification, seed, allocationCallbacks.pfnInternalAllocation ); - VULKAN_HPP_HASH_COMBINE( PFN_vkInternalFreeNotification, seed, allocationCallbacks.pfnInternalFree ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ComponentMapping { using NativeType = VkComponentMapping; @@ -4206,27 +4142,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkComponentMapping const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkComponentMapping const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkComponentMapping &() VULKAN_HPP_NOEXCEPT + explicit operator VkComponentMapping &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( r, g, b, a ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ComponentMapping const & ) const = default; #else bool operator==( ComponentMapping const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( r == rhs.r ) && ( g == rhs.g ) && ( b == rhs.b ) && ( a == rhs.a ); + return this->reflect() == rhs.reflect(); } bool operator!=( ComponentMapping const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -4243,24 +4192,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ComponentMapping is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ComponentMapping const & componentMapping ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentSwizzle, seed, componentMapping.r ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentSwizzle, seed, componentMapping.g ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentSwizzle, seed, componentMapping.b ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentSwizzle, seed, componentMapping.a ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_ANDROID_KHR ) struct AndroidHardwareBufferFormatProperties2ANDROID { @@ -4312,32 +4243,55 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkAndroidHardwareBufferFormatProperties2ANDROID const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAndroidHardwareBufferFormatProperties2ANDROID const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAndroidHardwareBufferFormatProperties2ANDROID &() VULKAN_HPP_NOEXCEPT + explicit operator VkAndroidHardwareBufferFormatProperties2ANDROID &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + format, + externalFormat, + formatFeatures, + samplerYcbcrConversionComponents, + suggestedYcbcrModel, + suggestedYcbcrRange, + suggestedXChromaOffset, + suggestedYChromaOffset ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AndroidHardwareBufferFormatProperties2ANDROID const & ) const = default; # else bool operator==( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && - ( externalFormat == rhs.externalFormat ) && ( formatFeatures == rhs.formatFeatures ) && - ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) && - ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) && - ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && - ( suggestedYChromaOffset == rhs.suggestedYChromaOffset ); + return this->reflect() == rhs.reflect(); } bool operator!=( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -4369,45 +4323,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = AndroidHardwareBufferFormatProperties2ANDROID; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID const & - androidHardwareBufferFormatProperties2ANDROID ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, androidHardwareBufferFormatProperties2ANDROID.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, androidHardwareBufferFormatProperties2ANDROID.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, androidHardwareBufferFormatProperties2ANDROID.format ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, androidHardwareBufferFormatProperties2ANDROID.externalFormat ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR, - seed, - androidHardwareBufferFormatProperties2ANDROID.formatFeatures ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentMapping, - seed, - androidHardwareBufferFormatProperties2ANDROID.samplerYcbcrConversionComponents ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion, - seed, - androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrModel ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerYcbcrRange, - seed, - androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrRange ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ChromaLocation, - seed, - androidHardwareBufferFormatProperties2ANDROID.suggestedXChromaOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ChromaLocation, - seed, - androidHardwareBufferFormatProperties2ANDROID.suggestedYChromaOffset ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ #if defined( VK_USE_PLATFORM_ANDROID_KHR ) @@ -4461,32 +4376,55 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkAndroidHardwareBufferFormatPropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAndroidHardwareBufferFormatPropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAndroidHardwareBufferFormatPropertiesANDROID &() VULKAN_HPP_NOEXCEPT + explicit operator VkAndroidHardwareBufferFormatPropertiesANDROID &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + format, + externalFormat, + formatFeatures, + samplerYcbcrConversionComponents, + suggestedYcbcrModel, + suggestedYcbcrRange, + suggestedXChromaOffset, + suggestedYChromaOffset ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AndroidHardwareBufferFormatPropertiesANDROID const & ) const = default; # else bool operator==( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && - ( externalFormat == rhs.externalFormat ) && ( formatFeatures == rhs.formatFeatures ) && - ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) && - ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) && - ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && - ( suggestedYChromaOffset == rhs.suggestedYChromaOffset ); + return this->reflect() == rhs.reflect(); } bool operator!=( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -4518,41 +4456,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = AndroidHardwareBufferFormatPropertiesANDROID; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID const & - androidHardwareBufferFormatPropertiesANDROID ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, androidHardwareBufferFormatPropertiesANDROID.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, androidHardwareBufferFormatPropertiesANDROID.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, androidHardwareBufferFormatPropertiesANDROID.format ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, androidHardwareBufferFormatPropertiesANDROID.externalFormat ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, androidHardwareBufferFormatPropertiesANDROID.formatFeatures ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentMapping, - seed, - androidHardwareBufferFormatPropertiesANDROID.samplerYcbcrConversionComponents ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion, - seed, - androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrModel ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SamplerYcbcrRange, seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrRange ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ChromaLocation, seed, androidHardwareBufferFormatPropertiesANDROID.suggestedXChromaOffset ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ChromaLocation, seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYChromaOffset ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ #if defined( VK_USE_PLATFORM_ANDROID_KHR ) @@ -4590,28 +4493,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkAndroidHardwareBufferPropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAndroidHardwareBufferPropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAndroidHardwareBufferPropertiesANDROID &() VULKAN_HPP_NOEXCEPT + explicit operator VkAndroidHardwareBufferPropertiesANDROID &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, allocationSize, memoryTypeBits ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AndroidHardwareBufferPropertiesANDROID const & ) const = default; # else bool operator==( AndroidHardwareBufferPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) && - ( memoryTypeBits == rhs.memoryTypeBits ); + return this->reflect() == rhs.reflect(); } bool operator!=( AndroidHardwareBufferPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -4636,27 +4551,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = AndroidHardwareBufferPropertiesANDROID; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID const & - androidHardwareBufferPropertiesANDROID ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, androidHardwareBufferPropertiesANDROID.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, androidHardwareBufferPropertiesANDROID.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceSize, seed, androidHardwareBufferPropertiesANDROID.allocationSize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, androidHardwareBufferPropertiesANDROID.memoryTypeBits ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ #if defined( VK_USE_PLATFORM_ANDROID_KHR ) @@ -4691,28 +4585,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkAndroidHardwareBufferUsageANDROID const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAndroidHardwareBufferUsageANDROID const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAndroidHardwareBufferUsageANDROID &() VULKAN_HPP_NOEXCEPT + explicit operator VkAndroidHardwareBufferUsageANDROID &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, androidHardwareBufferUsage ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AndroidHardwareBufferUsageANDROID const & ) const = default; # else bool operator==( AndroidHardwareBufferUsageANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( androidHardwareBufferUsage == rhs.androidHardwareBufferUsage ); + return this->reflect() == rhs.reflect(); } bool operator!=( AndroidHardwareBufferUsageANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -4735,25 +4638,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = AndroidHardwareBufferUsageANDROID; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID const & - androidHardwareBufferUsageANDROID ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, androidHardwareBufferUsageANDROID.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, androidHardwareBufferUsageANDROID.pNext ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, androidHardwareBufferUsageANDROID.androidHardwareBufferUsage ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ #if defined( VK_USE_PLATFORM_ANDROID_KHR ) @@ -4809,27 +4693,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAndroidSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAndroidSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAndroidSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkAndroidSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, window ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AndroidSurfaceCreateInfoKHR const & ) const = default; # else bool operator==( AndroidSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window ); + return this->reflect() == rhs.reflect(); } bool operator!=( AndroidSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -4853,27 +4750,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = AndroidSurfaceCreateInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & androidSurfaceCreateInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, androidSurfaceCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, androidSurfaceCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateFlagsKHR, seed, androidSurfaceCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( struct ANativeWindow *, seed, androidSurfaceCreateInfoKHR.window ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ struct ApplicationInfo @@ -4949,29 +4825,43 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkApplicationInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkApplicationInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkApplicationInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkApplicationInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pApplicationName, applicationVersion, pEngineName, engineVersion, apiVersion ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ApplicationInfo const & ) const = default; #else bool operator==( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pApplicationName == rhs.pApplicationName ) && - ( applicationVersion == rhs.applicationVersion ) && ( pEngineName == rhs.pEngineName ) && - ( engineVersion == rhs.engineVersion ) && ( apiVersion == rhs.apiVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -4997,27 +4887,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ApplicationInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ApplicationInfo const & applicationInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, applicationInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, applicationInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( const char *, seed, applicationInfo.pApplicationName ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, applicationInfo.applicationVersion ); - VULKAN_HPP_HASH_COMBINE( const char *, seed, applicationInfo.pEngineName ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, applicationInfo.engineVersion ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, applicationInfo.apiVersion ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AttachmentDescription { using NativeType = VkAttachmentDescription; @@ -5125,30 +4994,46 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAttachmentDescription const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAttachmentDescription const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAttachmentDescription &() VULKAN_HPP_NOEXCEPT + explicit operator VkAttachmentDescription &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + flags, format, samples, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalLayout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentDescription const & ) const = default; #else bool operator==( AttachmentDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && ( format == rhs.format ) && ( samples == rhs.samples ) && - ( loadOp == rhs.loadOp ) && ( storeOp == rhs.storeOp ) && ( stencilLoadOp == rhs.stencilLoadOp ) && - ( stencilStoreOp == rhs.stencilStoreOp ) && ( initialLayout == rhs.initialLayout ) && - ( finalLayout == rhs.finalLayout ); + return this->reflect() == rhs.reflect(); } bool operator!=( AttachmentDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -5170,30 +5055,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "AttachmentDescription is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription const & attachmentDescription ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags, seed, attachmentDescription.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, attachmentDescription.format ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, attachmentDescription.samples ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentLoadOp, seed, attachmentDescription.loadOp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentStoreOp, seed, attachmentDescription.storeOp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentLoadOp, seed, attachmentDescription.stencilLoadOp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentStoreOp, seed, attachmentDescription.stencilStoreOp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescription.initialLayout ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescription.finalLayout ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AttachmentDescription2 { using NativeType = VkAttachmentDescription2; @@ -5310,30 +5171,57 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAttachmentDescription2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAttachmentDescription2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAttachmentDescription2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkAttachmentDescription2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + format, + samples, + loadOp, + storeOp, + stencilLoadOp, + stencilStoreOp, + initialLayout, + finalLayout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentDescription2 const & ) const = default; #else bool operator==( AttachmentDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( format == rhs.format ) && - ( samples == rhs.samples ) && ( loadOp == rhs.loadOp ) && ( storeOp == rhs.storeOp ) && - ( stencilLoadOp == rhs.stencilLoadOp ) && ( stencilStoreOp == rhs.stencilStoreOp ) && - ( initialLayout == rhs.initialLayout ) && ( finalLayout == rhs.finalLayout ); + return this->reflect() == rhs.reflect(); } bool operator!=( AttachmentDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -5365,32 +5253,6 @@ namespace VULKAN_HPP_NAMESPACE }; using AttachmentDescription2KHR = AttachmentDescription2; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription2 const & attachmentDescription2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentDescription2.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, attachmentDescription2.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags, seed, attachmentDescription2.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, attachmentDescription2.format ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, attachmentDescription2.samples ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentLoadOp, seed, attachmentDescription2.loadOp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentStoreOp, seed, attachmentDescription2.storeOp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentLoadOp, seed, attachmentDescription2.stencilLoadOp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentStoreOp, seed, attachmentDescription2.stencilStoreOp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescription2.initialLayout ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescription2.finalLayout ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AttachmentDescriptionStencilLayout { using NativeType = VkAttachmentDescriptionStencilLayout; @@ -5448,28 +5310,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAttachmentDescriptionStencilLayout const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAttachmentDescriptionStencilLayout const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAttachmentDescriptionStencilLayout &() VULKAN_HPP_NOEXCEPT + explicit operator VkAttachmentDescriptionStencilLayout &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stencilInitialLayout, stencilFinalLayout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentDescriptionStencilLayout const & ) const = default; #else bool operator==( AttachmentDescriptionStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilInitialLayout == rhs.stencilInitialLayout ) && - ( stencilFinalLayout == rhs.stencilFinalLayout ); + return this->reflect() == rhs.reflect(); } bool operator!=( AttachmentDescriptionStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -5495,27 +5369,6 @@ namespace VULKAN_HPP_NAMESPACE }; using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout const & - attachmentDescriptionStencilLayout ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentDescriptionStencilLayout.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, attachmentDescriptionStencilLayout.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescriptionStencilLayout.stencilInitialLayout ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentDescriptionStencilLayout.stencilFinalLayout ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AttachmentReference { using NativeType = VkAttachmentReference; @@ -5558,27 +5411,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAttachmentReference const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAttachmentReference const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAttachmentReference &() VULKAN_HPP_NOEXCEPT + explicit operator VkAttachmentReference &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( attachment, layout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentReference const & ) const = default; #else bool operator==( AttachmentReference const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( attachment == rhs.attachment ) && ( layout == rhs.layout ); + return this->reflect() == rhs.reflect(); } bool operator!=( AttachmentReference const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -5593,23 +5456,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "AttachmentReference is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::AttachmentReference const & attachmentReference ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, attachmentReference.attachment ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentReference.layout ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AttachmentReference2 { using NativeType = VkAttachmentReference2; @@ -5670,28 +5516,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAttachmentReference2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAttachmentReference2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAttachmentReference2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkAttachmentReference2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, attachment, layout, aspectMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentReference2 const & ) const = default; #else bool operator==( AttachmentReference2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachment == rhs.attachment ) && - ( layout == rhs.layout ) && ( aspectMask == rhs.aspectMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( AttachmentReference2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -5716,26 +5575,6 @@ namespace VULKAN_HPP_NAMESPACE }; using AttachmentReference2KHR = AttachmentReference2; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::AttachmentReference2 const & attachmentReference2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentReference2.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, attachmentReference2.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, attachmentReference2.attachment ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentReference2.layout ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, attachmentReference2.aspectMask ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AttachmentReferenceStencilLayout { using NativeType = VkAttachmentReferenceStencilLayout; @@ -5782,27 +5621,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAttachmentReferenceStencilLayout const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAttachmentReferenceStencilLayout const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAttachmentReferenceStencilLayout &() VULKAN_HPP_NOEXCEPT + explicit operator VkAttachmentReferenceStencilLayout &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stencilLayout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentReferenceStencilLayout const & ) const = default; #else bool operator==( AttachmentReferenceStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilLayout == rhs.stencilLayout ); + return this->reflect() == rhs.reflect(); } bool operator!=( AttachmentReferenceStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -5827,25 +5676,6 @@ namespace VULKAN_HPP_NAMESPACE }; using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout const & attachmentReferenceStencilLayout ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentReferenceStencilLayout.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, attachmentReferenceStencilLayout.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, attachmentReferenceStencilLayout.stencilLayout ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AttachmentSampleCountInfoAMD { using NativeType = VkAttachmentSampleCountInfoAMD; @@ -5931,29 +5761,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAttachmentSampleCountInfoAMD const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAttachmentSampleCountInfoAMD const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAttachmentSampleCountInfoAMD &() VULKAN_HPP_NOEXCEPT + explicit operator VkAttachmentSampleCountInfoAMD &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, colorAttachmentCount, pColorAttachmentSamples, depthStencilAttachmentSamples ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentSampleCountInfoAMD const & ) const = default; #else bool operator==( AttachmentSampleCountInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && - ( pColorAttachmentSamples == rhs.pColorAttachmentSamples ) && - ( depthStencilAttachmentSamples == rhs.depthStencilAttachmentSamples ); + return this->reflect() == rhs.reflect(); } bool operator!=( AttachmentSampleCountInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -5981,28 +5823,6 @@ namespace VULKAN_HPP_NAMESPACE }; using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( - VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD const & attachmentSampleCountInfoAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, attachmentSampleCountInfoAMD.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, attachmentSampleCountInfoAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, attachmentSampleCountInfoAMD.colorAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::SampleCountFlagBits *, seed, attachmentSampleCountInfoAMD.pColorAttachmentSamples ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, attachmentSampleCountInfoAMD.depthStencilAttachmentSamples ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct Extent2D { using NativeType = VkExtent2D; @@ -6040,27 +5860,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkExtent2D const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExtent2D const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExtent2D &() VULKAN_HPP_NOEXCEPT + explicit operator VkExtent2D &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( width, height ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Extent2D const & ) const = default; #else bool operator==( Extent2D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( width == rhs.width ) && ( height == rhs.height ); + return this->reflect() == rhs.reflect(); } bool operator!=( Extent2D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -6075,22 +5905,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Extent2D is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent2D const & extent2D ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent2D.width ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent2D.height ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SampleLocationEXT { using NativeType = VkSampleLocationEXT; @@ -6130,27 +5944,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSampleLocationEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSampleLocationEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSampleLocationEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkSampleLocationEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SampleLocationEXT const & ) const = default; #else bool operator==( SampleLocationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( x == rhs.x ) && ( y == rhs.y ); + return this->reflect() == rhs.reflect(); } bool operator!=( SampleLocationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -6165,22 +5989,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SampleLocationEXT is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationEXT const & sampleLocationEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( float, seed, sampleLocationEXT.x ); - VULKAN_HPP_HASH_COMBINE( float, seed, sampleLocationEXT.y ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SampleLocationsInfoEXT { using NativeType = VkSampleLocationsInfoEXT; @@ -6276,30 +6084,43 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSampleLocationsInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSampleLocationsInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSampleLocationsInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkSampleLocationsInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, sampleLocationsPerPixel, sampleLocationGridSize, sampleLocationsCount, pSampleLocations ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SampleLocationsInfoEXT const & ) const = default; #else bool operator==( SampleLocationsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( sampleLocationsPerPixel == rhs.sampleLocationsPerPixel ) && - ( sampleLocationGridSize == rhs.sampleLocationGridSize ) && - ( sampleLocationsCount == rhs.sampleLocationsCount ) && ( pSampleLocations == rhs.pSampleLocations ); + return this->reflect() == rhs.reflect(); } bool operator!=( SampleLocationsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -6325,29 +6146,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = SampleLocationsInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sampleLocationsInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, sampleLocationsInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, sampleLocationsInfoEXT.sampleLocationsPerPixel ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, sampleLocationsInfoEXT.sampleLocationGridSize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sampleLocationsInfoEXT.sampleLocationsCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::SampleLocationEXT *, seed, sampleLocationsInfoEXT.pSampleLocations ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct AttachmentSampleLocationsEXT { using NativeType = VkAttachmentSampleLocationsEXT; @@ -6392,27 +6190,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkAttachmentSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkAttachmentSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkAttachmentSampleLocationsEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkAttachmentSampleLocationsEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( attachmentIndex, sampleLocationsInfo ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentSampleLocationsEXT const & ) const = default; #else bool operator==( AttachmentSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( attachmentIndex == rhs.attachmentIndex ) && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( AttachmentSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -6429,24 +6237,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "AttachmentSampleLocationsEXT is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( - VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT const & attachmentSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, attachmentSampleLocationsEXT.attachmentIndex ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT, seed, attachmentSampleLocationsEXT.sampleLocationsInfo ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BaseInStructure { using NativeType = VkBaseInStructure; @@ -6480,27 +6270,38 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBaseInStructure const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBaseInStructure const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBaseInStructure &() VULKAN_HPP_NOEXCEPT + explicit operator VkBaseInStructure &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BaseInStructure const & ) const = default; #else bool operator==( BaseInStructure const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); + return this->reflect() == rhs.reflect(); } bool operator!=( BaseInStructure const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -6515,22 +6316,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "BaseInStructure is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseInStructure const & baseInStructure ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, baseInStructure.sType ); - VULKAN_HPP_HASH_COMBINE( const struct VULKAN_HPP_NAMESPACE::BaseInStructure *, seed, baseInStructure.pNext ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BaseOutStructure { using NativeType = VkBaseOutStructure; @@ -6564,27 +6349,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBaseOutStructure const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBaseOutStructure const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBaseOutStructure &() VULKAN_HPP_NOEXCEPT + explicit operator VkBaseOutStructure &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BaseOutStructure const & ) const = default; #else bool operator==( BaseOutStructure const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); + return this->reflect() == rhs.reflect(); } bool operator!=( BaseOutStructure const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -6599,22 +6394,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "BaseOutStructure is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseOutStructure const & baseOutStructure ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, baseOutStructure.sType ); - VULKAN_HPP_HASH_COMBINE( struct VULKAN_HPP_NAMESPACE::BaseOutStructure *, seed, baseOutStructure.pNext ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BindAccelerationStructureMemoryInfoNV { using NativeType = VkBindAccelerationStructureMemoryInfoNV; @@ -6723,30 +6502,43 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBindAccelerationStructureMemoryInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBindAccelerationStructureMemoryInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBindAccelerationStructureMemoryInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkBindAccelerationStructureMemoryInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, accelerationStructure, memory, memoryOffset, deviceIndexCount, pDeviceIndices ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindAccelerationStructureMemoryInfoNV const & ) const = default; #else bool operator==( BindAccelerationStructureMemoryInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( accelerationStructure == rhs.accelerationStructure ) && ( memory == rhs.memory ) && - ( memoryOffset == rhs.memoryOffset ) && ( deviceIndexCount == rhs.deviceIndexCount ) && - ( pDeviceIndices == rhs.pDeviceIndices ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindAccelerationStructureMemoryInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -6774,31 +6566,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = BindAccelerationStructureMemoryInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV const & - bindAccelerationStructureMemoryInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindAccelerationStructureMemoryInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bindAccelerationStructureMemoryInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccelerationStructureNV, - seed, - bindAccelerationStructureMemoryInfoNV.accelerationStructure ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, bindAccelerationStructureMemoryInfoNV.memory ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceSize, seed, bindAccelerationStructureMemoryInfoNV.memoryOffset ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindAccelerationStructureMemoryInfoNV.deviceIndexCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, bindAccelerationStructureMemoryInfoNV.pDeviceIndices ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BindBufferMemoryDeviceGroupInfo { using NativeType = VkBindBufferMemoryDeviceGroupInfo; @@ -6869,28 +6636,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBindBufferMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBindBufferMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBindBufferMemoryDeviceGroupInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkBindBufferMemoryDeviceGroupInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceIndexCount, pDeviceIndices ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindBufferMemoryDeviceGroupInfo const & ) const = default; #else bool operator==( BindBufferMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) && - ( pDeviceIndices == rhs.pDeviceIndices ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindBufferMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -6916,26 +6695,6 @@ namespace VULKAN_HPP_NAMESPACE }; using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo const & bindBufferMemoryDeviceGroupInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindBufferMemoryDeviceGroupInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bindBufferMemoryDeviceGroupInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindBufferMemoryDeviceGroupInfo.deviceIndexCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, bindBufferMemoryDeviceGroupInfo.pDeviceIndices ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BindBufferMemoryInfo { using NativeType = VkBindBufferMemoryInfo; @@ -6995,28 +6754,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBindBufferMemoryInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBindBufferMemoryInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBindBufferMemoryInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkBindBufferMemoryInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer, memory, memoryOffset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindBufferMemoryInfo const & ) const = default; #else bool operator==( BindBufferMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( memory == rhs.memory ) && - ( memoryOffset == rhs.memoryOffset ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindBufferMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -7041,26 +6813,6 @@ namespace VULKAN_HPP_NAMESPACE }; using BindBufferMemoryInfoKHR = BindBufferMemoryInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo const & bindBufferMemoryInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindBufferMemoryInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bindBufferMemoryInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bindBufferMemoryInfo.buffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, bindBufferMemoryInfo.memory ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bindBufferMemoryInfo.memoryOffset ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct Offset2D { using NativeType = VkOffset2D; @@ -7098,27 +6850,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkOffset2D const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkOffset2D const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkOffset2D &() VULKAN_HPP_NOEXCEPT + explicit operator VkOffset2D &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Offset2D const & ) const = default; #else bool operator==( Offset2D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( x == rhs.x ) && ( y == rhs.y ); + return this->reflect() == rhs.reflect(); } bool operator!=( Offset2D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -7133,22 +6895,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Offset2D is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset2D const & offset2D ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset2D.x ); - VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset2D.y ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct Rect2D { using NativeType = VkRect2D; @@ -7187,27 +6933,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRect2D const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRect2D const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRect2D &() VULKAN_HPP_NOEXCEPT + explicit operator VkRect2D &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( offset, extent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Rect2D const & ) const = default; #else bool operator==( Rect2D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( offset == rhs.offset ) && ( extent == rhs.extent ); + return this->reflect() == rhs.reflect(); } bool operator!=( Rect2D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -7222,22 +6978,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Rect2D is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::Rect2D const & rect2D ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, rect2D.offset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, rect2D.extent ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BindImageMemoryDeviceGroupInfo { using NativeType = VkBindImageMemoryDeviceGroupInfo; @@ -7343,30 +7083,43 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBindImageMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBindImageMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBindImageMemoryDeviceGroupInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkBindImageMemoryDeviceGroupInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, deviceIndexCount, pDeviceIndices, splitInstanceBindRegionCount, pSplitInstanceBindRegions ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindImageMemoryDeviceGroupInfo const & ) const = default; #else bool operator==( BindImageMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) && - ( pDeviceIndices == rhs.pDeviceIndices ) && - ( splitInstanceBindRegionCount == rhs.splitInstanceBindRegionCount ) && - ( pSplitInstanceBindRegions == rhs.pSplitInstanceBindRegions ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindImageMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -7394,28 +7147,6 @@ namespace VULKAN_HPP_NAMESPACE }; using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo const & bindImageMemoryDeviceGroupInfo ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindImageMemoryDeviceGroupInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bindImageMemoryDeviceGroupInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindImageMemoryDeviceGroupInfo.deviceIndexCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, bindImageMemoryDeviceGroupInfo.pDeviceIndices ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindImageMemoryDeviceGroupInfo.splitInstanceBindRegionCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::Rect2D *, seed, bindImageMemoryDeviceGroupInfo.pSplitInstanceBindRegions ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BindImageMemoryInfo { using NativeType = VkBindImageMemoryInfo; @@ -7475,28 +7206,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBindImageMemoryInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBindImageMemoryInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBindImageMemoryInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkBindImageMemoryInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image, memory, memoryOffset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindImageMemoryInfo const & ) const = default; #else bool operator==( BindImageMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( memory == rhs.memory ) && - ( memoryOffset == rhs.memoryOffset ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindImageMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -7521,26 +7265,6 @@ namespace VULKAN_HPP_NAMESPACE }; using BindImageMemoryInfoKHR = BindImageMemoryInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryInfo const & bindImageMemoryInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindImageMemoryInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bindImageMemoryInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, bindImageMemoryInfo.image ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, bindImageMemoryInfo.memory ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bindImageMemoryInfo.memoryOffset ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BindImageMemorySwapchainInfoKHR { using NativeType = VkBindImageMemorySwapchainInfoKHR; @@ -7593,28 +7317,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBindImageMemorySwapchainInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBindImageMemorySwapchainInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBindImageMemorySwapchainInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkBindImageMemorySwapchainInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchain, imageIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindImageMemorySwapchainInfoKHR const & ) const = default; #else bool operator==( BindImageMemorySwapchainInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && - ( imageIndex == rhs.imageIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindImageMemorySwapchainInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -7639,26 +7375,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = BindImageMemorySwapchainInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR const & bindImageMemorySwapchainInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindImageMemorySwapchainInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bindImageMemorySwapchainInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainKHR, seed, bindImageMemorySwapchainInfoKHR.swapchain ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindImageMemorySwapchainInfoKHR.imageIndex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BindImagePlaneMemoryInfo { using NativeType = VkBindImagePlaneMemoryInfo; @@ -7703,27 +7419,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBindImagePlaneMemoryInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBindImagePlaneMemoryInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBindImagePlaneMemoryInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkBindImagePlaneMemoryInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, planeAspect ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindImagePlaneMemoryInfo const & ) const = default; #else bool operator==( BindImagePlaneMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindImagePlaneMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -7747,24 +7475,6 @@ namespace VULKAN_HPP_NAMESPACE }; using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo const & bindImagePlaneMemoryInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindImagePlaneMemoryInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bindImagePlaneMemoryInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlagBits, seed, bindImagePlaneMemoryInfo.planeAspect ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BindIndexBufferIndirectCommandNV { using NativeType = VkBindIndexBufferIndirectCommandNV; @@ -7818,27 +7528,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBindIndexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBindIndexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBindIndexBufferIndirectCommandNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkBindIndexBufferIndirectCommandNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( bufferAddress, size, indexType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindIndexBufferIndirectCommandNV const & ) const = default; #else bool operator==( BindIndexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( indexType == rhs.indexType ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindIndexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -7856,26 +7576,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "BindIndexBufferIndirectCommandNV is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV const & bindIndexBufferIndirectCommandNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceAddress, seed, bindIndexBufferIndirectCommandNV.bufferAddress ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindIndexBufferIndirectCommandNV.size ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::IndexType, seed, bindIndexBufferIndirectCommandNV.indexType ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BindShaderGroupIndirectCommandNV { using NativeType = VkBindShaderGroupIndirectCommandNV; @@ -7910,27 +7610,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBindShaderGroupIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBindShaderGroupIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBindShaderGroupIndirectCommandNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkBindShaderGroupIndirectCommandNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( groupIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindShaderGroupIndirectCommandNV const & ) const = default; #else bool operator==( BindShaderGroupIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( groupIndex == rhs.groupIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindShaderGroupIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -7946,23 +7656,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "BindShaderGroupIndirectCommandNV is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV const & bindShaderGroupIndirectCommandNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindShaderGroupIndirectCommandNV.groupIndex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SparseMemoryBind { using NativeType = VkSparseMemoryBind; @@ -8031,28 +7724,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSparseMemoryBind const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSparseMemoryBind const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSparseMemoryBind &() VULKAN_HPP_NOEXCEPT + explicit operator VkSparseMemoryBind &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( resourceOffset, size, memory, memoryOffset, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseMemoryBind const & ) const = default; #else bool operator==( SparseMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( resourceOffset == rhs.resourceOffset ) && ( size == rhs.size ) && ( memory == rhs.memory ) && - ( memoryOffset == rhs.memoryOffset ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( SparseMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -8070,25 +7776,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SparseMemoryBind is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseMemoryBind const & sparseMemoryBind ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseMemoryBind.resourceOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseMemoryBind.size ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, sparseMemoryBind.memory ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseMemoryBind.memoryOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags, seed, sparseMemoryBind.flags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SparseBufferMemoryBindInfo { using NativeType = VkSparseBufferMemoryBindInfo; @@ -8160,27 +7847,39 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSparseBufferMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSparseBufferMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSparseBufferMemoryBindInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkSparseBufferMemoryBindInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( buffer, bindCount, pBinds ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseBufferMemoryBindInfo const & ) const = default; #else bool operator==( SparseBufferMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( buffer == rhs.buffer ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds ); + return this->reflect() == rhs.reflect(); } bool operator!=( SparseBufferMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -8197,24 +7896,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SparseBufferMemoryBindInfo is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo const & sparseBufferMemoryBindInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, sparseBufferMemoryBindInfo.buffer ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sparseBufferMemoryBindInfo.bindCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SparseMemoryBind *, seed, sparseBufferMemoryBindInfo.pBinds ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SparseImageOpaqueMemoryBindInfo { using NativeType = VkSparseImageOpaqueMemoryBindInfo; @@ -8287,27 +7968,39 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSparseImageOpaqueMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSparseImageOpaqueMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSparseImageOpaqueMemoryBindInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkSparseImageOpaqueMemoryBindInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( image, bindCount, pBinds ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageOpaqueMemoryBindInfo const & ) const = default; #else bool operator==( SparseImageOpaqueMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( image == rhs.image ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds ); + return this->reflect() == rhs.reflect(); } bool operator!=( SparseImageOpaqueMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -8325,26 +8018,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "SparseImageOpaqueMemoryBindInfo is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo const & sparseImageOpaqueMemoryBindInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, sparseImageOpaqueMemoryBindInfo.image ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sparseImageOpaqueMemoryBindInfo.bindCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::SparseMemoryBind *, seed, sparseImageOpaqueMemoryBindInfo.pBinds ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageSubresource { using NativeType = VkImageSubresource; @@ -8394,27 +8067,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageSubresource const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageSubresource const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageSubresource &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageSubresource &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( aspectMask, mipLevel, arrayLayer ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageSubresource const & ) const = default; #else bool operator==( ImageSubresource const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( aspectMask == rhs.aspectMask ) && ( mipLevel == rhs.mipLevel ) && ( arrayLayer == rhs.arrayLayer ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageSubresource const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -8430,23 +8113,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageSubresource is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource const & imageSubresource ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, imageSubresource.aspectMask ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresource.mipLevel ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresource.arrayLayer ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct Offset3D { using NativeType = VkOffset3D; @@ -8493,27 +8159,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkOffset3D const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkOffset3D const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkOffset3D &() VULKAN_HPP_NOEXCEPT + explicit operator VkOffset3D &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y, z ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Offset3D const & ) const = default; #else bool operator==( Offset3D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z ); + return this->reflect() == rhs.reflect(); } bool operator!=( Offset3D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -8529,23 +8205,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Offset3D is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset3D const & offset3D ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset3D.x ); - VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset3D.y ); - VULKAN_HPP_HASH_COMBINE( int32_t, seed, offset3D.z ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct Extent3D { using NativeType = VkExtent3D; @@ -8595,27 +8254,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkExtent3D const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExtent3D const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExtent3D &() VULKAN_HPP_NOEXCEPT + explicit operator VkExtent3D &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( width, height, depth ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Extent3D const & ) const = default; #else bool operator==( Extent3D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( width == rhs.width ) && ( height == rhs.height ) && ( depth == rhs.depth ); + return this->reflect() == rhs.reflect(); } bool operator!=( Extent3D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -8631,23 +8300,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Extent3D is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent3D const & extent3D ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent3D.width ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent3D.height ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extent3D.depth ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SparseImageMemoryBind { using NativeType = VkSparseImageMemoryBind; @@ -8727,28 +8379,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSparseImageMemoryBind const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSparseImageMemoryBind const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSparseImageMemoryBind &() VULKAN_HPP_NOEXCEPT + explicit operator VkSparseImageMemoryBind &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( subresource, offset, extent, memory, memoryOffset, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageMemoryBind const & ) const = default; #else bool operator==( SparseImageMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( subresource == rhs.subresource ) && ( offset == rhs.offset ) && ( extent == rhs.extent ) && - ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( SparseImageMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -8767,27 +8433,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SparseImageMemoryBind is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBind const & sparseImageMemoryBind ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresource, seed, sparseImageMemoryBind.subresource ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, sparseImageMemoryBind.offset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, sparseImageMemoryBind.extent ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, sparseImageMemoryBind.memory ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseImageMemoryBind.memoryOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags, seed, sparseImageMemoryBind.flags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SparseImageMemoryBindInfo { using NativeType = VkSparseImageMemoryBindInfo; @@ -8859,27 +8504,39 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSparseImageMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSparseImageMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSparseImageMemoryBindInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkSparseImageMemoryBindInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( image, bindCount, pBinds ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageMemoryBindInfo const & ) const = default; #else bool operator==( SparseImageMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( image == rhs.image ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds ); + return this->reflect() == rhs.reflect(); } bool operator!=( SparseImageMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -8896,25 +8553,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SparseImageMemoryBindInfo is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo const & sparseImageMemoryBindInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, sparseImageMemoryBindInfo.image ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sparseImageMemoryBindInfo.bindCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::SparseImageMemoryBind *, seed, sparseImageMemoryBindInfo.pBinds ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BindSparseInfo { using NativeType = VkBindSparseInfo; @@ -9115,32 +8753,59 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBindSparseInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkBindSparseInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + waitSemaphoreCount, + pWaitSemaphores, + bufferBindCount, + pBufferBinds, + imageOpaqueBindCount, + pImageOpaqueBinds, + imageBindCount, + pImageBinds, + signalSemaphoreCount, + pSignalSemaphores ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindSparseInfo const & ) const = default; #else bool operator==( BindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) && - ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( bufferBindCount == rhs.bufferBindCount ) && - ( pBufferBinds == rhs.pBufferBinds ) && ( imageOpaqueBindCount == rhs.imageOpaqueBindCount ) && - ( pImageOpaqueBinds == rhs.pImageOpaqueBinds ) && ( imageBindCount == rhs.imageBindCount ) && - ( pImageBinds == rhs.pImageBinds ) && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) && - ( pSignalSemaphores == rhs.pSignalSemaphores ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -9171,35 +8836,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = BindSparseInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindSparseInfo const & bindSparseInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bindSparseInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bindSparseInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.waitSemaphoreCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, bindSparseInfo.pWaitSemaphores ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.bufferBindCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo *, seed, bindSparseInfo.pBufferBinds ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.imageOpaqueBindCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo *, seed, bindSparseInfo.pImageOpaqueBinds ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.imageBindCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo *, seed, bindSparseInfo.pImageBinds ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindSparseInfo.signalSemaphoreCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, bindSparseInfo.pSignalSemaphores ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BindVertexBufferIndirectCommandNV { using NativeType = VkBindVertexBufferIndirectCommandNV; @@ -9251,27 +8887,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBindVertexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBindVertexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBindVertexBufferIndirectCommandNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkBindVertexBufferIndirectCommandNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( bufferAddress, size, stride ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindVertexBufferIndirectCommandNV const & ) const = default; #else bool operator==( BindVertexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( stride == rhs.stride ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindVertexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -9289,25 +8935,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "BindVertexBufferIndirectCommandNV is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV const & - bindVertexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceAddress, seed, bindVertexBufferIndirectCommandNV.bufferAddress ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindVertexBufferIndirectCommandNV.size ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bindVertexBufferIndirectCommandNV.stride ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageSubresourceLayers { using NativeType = VkImageSubresourceLayers; @@ -9365,28 +8992,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageSubresourceLayers const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageSubresourceLayers const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageSubresourceLayers &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageSubresourceLayers &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( aspectMask, mipLevel, baseArrayLayer, layerCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageSubresourceLayers const & ) const = default; #else bool operator==( ImageSubresourceLayers const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( aspectMask == rhs.aspectMask ) && ( mipLevel == rhs.mipLevel ) && - ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageSubresourceLayers const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -9404,25 +9040,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageSubresourceLayers is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & imageSubresourceLayers ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, imageSubresourceLayers.aspectMask ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceLayers.mipLevel ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceLayers.baseArrayLayer ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceLayers.layerCount ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageBlit2KHR { using NativeType = VkImageBlit2KHR; @@ -9493,29 +9110,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageBlit2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageBlit2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageBlit2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageBlit2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcSubresource, srcOffsets, dstSubresource, dstOffsets ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageBlit2KHR const & ) const = default; #else bool operator==( ImageBlit2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && - ( srcOffsets == rhs.srcOffsets ) && ( dstSubresource == rhs.dstSubresource ) && - ( dstOffsets == rhs.dstOffsets ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageBlit2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -9540,32 +9170,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImageBlit2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit2KHR const & imageBlit2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageBlit2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageBlit2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageBlit2KHR.srcSubresource ); - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageBlit2KHR.srcOffsets[i] ); - } - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageBlit2KHR.dstSubresource ); - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageBlit2KHR.dstOffsets[i] ); - } - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BlitImageInfo2KHR { using NativeType = VkBlitImageInfo2KHR; @@ -9688,30 +9292,46 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBlitImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBlitImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBlitImageInfo2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkBlitImageInfo2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BlitImageInfo2KHR const & ) const = default; #else bool operator==( BlitImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && - ( srcImageLayout == rhs.srcImageLayout ) && ( dstImage == rhs.dstImage ) && - ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && - ( pRegions == rhs.pRegions ) && ( filter == rhs.filter ); + return this->reflect() == rhs.reflect(); } bool operator!=( BlitImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -9739,29 +9359,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = BlitImageInfo2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR const & blitImageInfo2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, blitImageInfo2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, blitImageInfo2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, blitImageInfo2KHR.srcImage ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, blitImageInfo2KHR.srcImageLayout ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, blitImageInfo2KHR.dstImage ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, blitImageInfo2KHR.dstImageLayout ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, blitImageInfo2KHR.regionCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageBlit2KHR *, seed, blitImageInfo2KHR.pRegions ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Filter, seed, blitImageInfo2KHR.filter ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_FUCHSIA ) struct BufferCollectionBufferCreateInfoFUCHSIA { @@ -9820,28 +9417,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBufferCollectionBufferCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBufferCollectionBufferCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBufferCollectionBufferCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + explicit operator VkBufferCollectionBufferCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, collection, index ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCollectionBufferCreateInfoFUCHSIA const & ) const = default; # else bool operator==( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && - ( index == rhs.index ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -9866,27 +9475,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = BufferCollectionBufferCreateInfoFUCHSIA; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA const & - bufferCollectionBufferCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionBufferCreateInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCollectionBufferCreateInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, seed, bufferCollectionBufferCreateInfoFUCHSIA.collection ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionBufferCreateInfoFUCHSIA.index ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_FUCHSIA*/ #if defined( VK_USE_PLATFORM_FUCHSIA ) @@ -9974,30 +9562,49 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBufferCollectionConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBufferCollectionConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBufferCollectionConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + explicit operator VkBufferCollectionConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + minBufferCount, + maxBufferCount, + minBufferCountForCamping, + minBufferCountForDedicatedSlack, + minBufferCountForSharedSlack ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCollectionConstraintsInfoFUCHSIA const & ) const = default; # else bool operator==( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minBufferCount == rhs.minBufferCount ) && - ( maxBufferCount == rhs.maxBufferCount ) && ( minBufferCountForCamping == rhs.minBufferCountForCamping ) && - ( minBufferCountForDedicatedSlack == rhs.minBufferCountForDedicatedSlack ) && - ( minBufferCountForSharedSlack == rhs.minBufferCountForSharedSlack ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -10025,29 +9632,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = BufferCollectionConstraintsInfoFUCHSIA; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const & - bufferCollectionConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionConstraintsInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCollectionConstraintsInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.maxBufferCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForCamping ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForDedicatedSlack ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForSharedSlack ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_FUCHSIA*/ #if defined( VK_USE_PLATFORM_FUCHSIA ) @@ -10096,28 +9680,37 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBufferCollectionCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBufferCollectionCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBufferCollectionCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + explicit operator VkBufferCollectionCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, collectionToken ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCollectionCreateInfoFUCHSIA const & ) const = default; # else bool operator==( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( memcmp( &collectionToken, &rhs.collectionToken, sizeof( zx_handle_t ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -10140,25 +9733,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = BufferCollectionCreateInfoFUCHSIA; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & - bufferCollectionCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionCreateInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCollectionCreateInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( zx_handle_t, seed, bufferCollectionCreateInfoFUCHSIA.collectionToken ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_FUCHSIA*/ #if defined( VK_USE_PLATFORM_FUCHSIA ) @@ -10218,28 +9792,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBufferCollectionImageCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBufferCollectionImageCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBufferCollectionImageCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + explicit operator VkBufferCollectionImageCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, collection, index ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCollectionImageCreateInfoFUCHSIA const & ) const = default; # else bool operator==( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && - ( index == rhs.index ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -10264,27 +9850,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = BufferCollectionImageCreateInfoFUCHSIA; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA const & - bufferCollectionImageCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionImageCreateInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCollectionImageCreateInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, seed, bufferCollectionImageCreateInfoFUCHSIA.collection ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionImageCreateInfoFUCHSIA.index ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_FUCHSIA*/ #if defined( VK_USE_PLATFORM_FUCHSIA ) @@ -10329,27 +9894,37 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSysmemColorSpaceFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSysmemColorSpaceFUCHSIA const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSysmemColorSpaceFUCHSIA &() VULKAN_HPP_NOEXCEPT + explicit operator VkSysmemColorSpaceFUCHSIA &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, colorSpace ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SysmemColorSpaceFUCHSIA const & ) const = default; # else bool operator==( SysmemColorSpaceFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorSpace == rhs.colorSpace ); + return this->reflect() == rhs.reflect(); } bool operator!=( SysmemColorSpaceFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -10371,25 +9946,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = SysmemColorSpaceFUCHSIA; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA const & sysmemColorSpaceFUCHSIA ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sysmemColorSpaceFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, sysmemColorSpaceFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sysmemColorSpaceFUCHSIA.colorSpace ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_FUCHSIA*/ #if defined( VK_USE_PLATFORM_FUCHSIA ) @@ -10531,34 +10087,61 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBufferCollectionPropertiesFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBufferCollectionPropertiesFUCHSIA const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBufferCollectionPropertiesFUCHSIA &() VULKAN_HPP_NOEXCEPT + explicit operator VkBufferCollectionPropertiesFUCHSIA &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + memoryTypeBits, + bufferCount, + createInfoIndex, + sysmemPixelFormat, + formatFeatures, + sysmemColorSpaceIndex, + samplerYcbcrConversionComponents, + suggestedYcbcrModel, + suggestedYcbcrRange, + suggestedXChromaOffset, + suggestedYChromaOffset ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCollectionPropertiesFUCHSIA const & ) const = default; # else bool operator==( BufferCollectionPropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ) && - ( bufferCount == rhs.bufferCount ) && ( createInfoIndex == rhs.createInfoIndex ) && - ( sysmemPixelFormat == rhs.sysmemPixelFormat ) && ( formatFeatures == rhs.formatFeatures ) && - ( sysmemColorSpaceIndex == rhs.sysmemColorSpaceIndex ) && - ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) && - ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) && - ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && - ( suggestedYChromaOffset == rhs.suggestedYChromaOffset ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferCollectionPropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -10592,43 +10175,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = BufferCollectionPropertiesFUCHSIA; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA const & - bufferCollectionPropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCollectionPropertiesFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, bufferCollectionPropertiesFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionPropertiesFUCHSIA.memoryTypeBits ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionPropertiesFUCHSIA.bufferCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCollectionPropertiesFUCHSIA.createInfoIndex ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, bufferCollectionPropertiesFUCHSIA.sysmemPixelFormat ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, bufferCollectionPropertiesFUCHSIA.formatFeatures ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA, seed, bufferCollectionPropertiesFUCHSIA.sysmemColorSpaceIndex ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentMapping, - seed, - bufferCollectionPropertiesFUCHSIA.samplerYcbcrConversionComponents ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion, seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrModel ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SamplerYcbcrRange, seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrRange ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ChromaLocation, seed, bufferCollectionPropertiesFUCHSIA.suggestedXChromaOffset ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ChromaLocation, seed, bufferCollectionPropertiesFUCHSIA.suggestedYChromaOffset ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_FUCHSIA*/ struct BufferCreateInfo @@ -10743,30 +10289,44 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBufferCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkBufferCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, size, usage, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCreateInfo const & ) const = default; #else bool operator==( BufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( size == rhs.size ) && - ( usage == rhs.usage ) && ( sharingMode == rhs.sharingMode ) && - ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && - ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -10793,28 +10353,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = BufferCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & bufferCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCreateFlags, seed, bufferCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCreateInfo.size ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferUsageFlags, seed, bufferCreateInfo.usage ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SharingMode, seed, bufferCreateInfo.sharingMode ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferCreateInfo.queueFamilyIndexCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, bufferCreateInfo.pQueueFamilyIndices ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_FUCHSIA ) struct BufferConstraintsInfoFUCHSIA { @@ -10880,29 +10418,41 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBufferConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBufferConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBufferConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + explicit operator VkBufferConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, createInfo, requiredFormatFeatures, bufferCollectionConstraints ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferConstraintsInfoFUCHSIA const & ) const = default; # else bool operator==( BufferConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createInfo == rhs.createInfo ) && - ( requiredFormatFeatures == rhs.requiredFormatFeatures ) && - ( bufferCollectionConstraints == rhs.bufferCollectionConstraints ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -10927,30 +10477,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = BufferConstraintsInfoFUCHSIA; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( - VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA const & bufferConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferConstraintsInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferConstraintsInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCreateInfo, seed, bufferConstraintsInfoFUCHSIA.createInfo ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, bufferConstraintsInfoFUCHSIA.requiredFormatFeatures ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA, - seed, - bufferConstraintsInfoFUCHSIA.bufferCollectionConstraints ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_FUCHSIA*/ struct BufferCopy @@ -11001,27 +10527,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBufferCopy const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBufferCopy const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBufferCopy &() VULKAN_HPP_NOEXCEPT + explicit operator VkBufferCopy &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcOffset, dstOffset, size ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCopy const & ) const = default; #else bool operator==( BufferCopy const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( srcOffset == rhs.srcOffset ) && ( dstOffset == rhs.dstOffset ) && ( size == rhs.size ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferCopy const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -11037,23 +10575,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "BufferCopy is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy const & bufferCopy ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy.srcOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy.dstOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy.size ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BufferCopy2KHR { using NativeType = VkBufferCopy2KHR; @@ -11113,28 +10634,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBufferCopy2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBufferCopy2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBufferCopy2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkBufferCopy2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcOffset, dstOffset, size ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCopy2KHR const & ) const = default; #else bool operator==( BufferCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcOffset == rhs.srcOffset ) && - ( dstOffset == rhs.dstOffset ) && ( size == rhs.size ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -11158,25 +10692,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = BufferCopy2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy2KHR const & bufferCopy2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferCopy2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferCopy2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy2KHR.srcOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy2KHR.dstOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferCopy2KHR.size ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BufferDeviceAddressCreateInfoEXT { using NativeType = VkBufferDeviceAddressCreateInfoEXT; @@ -11222,27 +10737,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBufferDeviceAddressCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBufferDeviceAddressCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBufferDeviceAddressCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkBufferDeviceAddressCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceAddress ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferDeviceAddressCreateInfoEXT const & ) const = default; #else bool operator==( BufferDeviceAddressCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferDeviceAddressCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -11266,26 +10793,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = BufferDeviceAddressCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT const & bufferDeviceAddressCreateInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferDeviceAddressCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferDeviceAddressCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceAddress, seed, bufferDeviceAddressCreateInfoEXT.deviceAddress ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BufferDeviceAddressInfo { using NativeType = VkBufferDeviceAddressInfo; @@ -11328,27 +10835,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBufferDeviceAddressInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBufferDeviceAddressInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBufferDeviceAddressInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkBufferDeviceAddressInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferDeviceAddressInfo const & ) const = default; #else bool operator==( BufferDeviceAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferDeviceAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -11373,24 +10890,6 @@ namespace VULKAN_HPP_NAMESPACE using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo; using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo const & bufferDeviceAddressInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferDeviceAddressInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferDeviceAddressInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferDeviceAddressInfo.buffer ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BufferImageCopy { using NativeType = VkBufferImageCopy; @@ -11467,29 +10966,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBufferImageCopy const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBufferImageCopy const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBufferImageCopy &() VULKAN_HPP_NOEXCEPT + explicit operator VkBufferImageCopy &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferImageCopy const & ) const = default; #else bool operator==( BufferImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( bufferOffset == rhs.bufferOffset ) && ( bufferRowLength == rhs.bufferRowLength ) && - ( bufferImageHeight == rhs.bufferImageHeight ) && ( imageSubresource == rhs.imageSubresource ) && - ( imageOffset == rhs.imageOffset ) && ( imageExtent == rhs.imageExtent ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -11508,26 +11020,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "BufferImageCopy is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy const & bufferImageCopy ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferImageCopy.bufferOffset ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferImageCopy.bufferRowLength ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferImageCopy.bufferImageHeight ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, bufferImageCopy.imageSubresource ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, bufferImageCopy.imageOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, bufferImageCopy.imageExtent ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BufferImageCopy2KHR { using NativeType = VkBufferImageCopy2KHR; @@ -11614,30 +11106,45 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBufferImageCopy2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBufferImageCopy2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBufferImageCopy2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkBufferImageCopy2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferImageCopy2KHR const & ) const = default; #else bool operator==( BufferImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferOffset == rhs.bufferOffset ) && - ( bufferRowLength == rhs.bufferRowLength ) && ( bufferImageHeight == rhs.bufferImageHeight ) && - ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) && - ( imageExtent == rhs.imageExtent ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -11664,29 +11171,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = BufferImageCopy2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR const & bufferImageCopy2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferImageCopy2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferImageCopy2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferImageCopy2KHR.bufferOffset ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferImageCopy2KHR.bufferRowLength ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferImageCopy2KHR.bufferImageHeight ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, bufferImageCopy2KHR.imageSubresource ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, bufferImageCopy2KHR.imageOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, bufferImageCopy2KHR.imageExtent ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BufferMemoryBarrier { using NativeType = VkBufferMemoryBarrier; @@ -11781,30 +11265,46 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBufferMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBufferMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBufferMemoryBarrier &() VULKAN_HPP_NOEXCEPT + explicit operator VkBufferMemoryBarrier &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, srcAccessMask, dstAccessMask, srcQueueFamilyIndex, dstQueueFamilyIndex, buffer, offset, size ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferMemoryBarrier const & ) const = default; #else bool operator==( BufferMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) && - ( dstAccessMask == rhs.dstAccessMask ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && - ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( buffer == rhs.buffer ) && - ( offset == rhs.offset ) && ( size == rhs.size ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -11832,30 +11332,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = BufferMemoryBarrier; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier const & bufferMemoryBarrier ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferMemoryBarrier.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferMemoryBarrier.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, bufferMemoryBarrier.srcAccessMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, bufferMemoryBarrier.dstAccessMask ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferMemoryBarrier.srcQueueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferMemoryBarrier.dstQueueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferMemoryBarrier.buffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferMemoryBarrier.offset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferMemoryBarrier.size ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BufferMemoryBarrier2KHR { using NativeType = VkBufferMemoryBarrier2KHR; @@ -11970,31 +11446,57 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBufferMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBufferMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBufferMemoryBarrier2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkBufferMemoryBarrier2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + srcStageMask, + srcAccessMask, + dstStageMask, + dstAccessMask, + srcQueueFamilyIndex, + dstQueueFamilyIndex, + buffer, + offset, + size ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferMemoryBarrier2KHR const & ) const = default; #else bool operator==( BufferMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && - ( srcAccessMask == rhs.srcAccessMask ) && ( dstStageMask == rhs.dstStageMask ) && - ( dstAccessMask == rhs.dstAccessMask ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && - ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( buffer == rhs.buffer ) && - ( offset == rhs.offset ) && ( size == rhs.size ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -12025,32 +11527,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = BufferMemoryBarrier2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2KHR const & bufferMemoryBarrier2KHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferMemoryBarrier2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferMemoryBarrier2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, bufferMemoryBarrier2KHR.srcStageMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, bufferMemoryBarrier2KHR.srcAccessMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, bufferMemoryBarrier2KHR.dstStageMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, bufferMemoryBarrier2KHR.dstAccessMask ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferMemoryBarrier2KHR.srcQueueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, bufferMemoryBarrier2KHR.dstQueueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferMemoryBarrier2KHR.buffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferMemoryBarrier2KHR.offset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferMemoryBarrier2KHR.size ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BufferMemoryRequirementsInfo2 { using NativeType = VkBufferMemoryRequirementsInfo2; @@ -12095,27 +11571,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBufferMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBufferMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBufferMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkBufferMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferMemoryRequirementsInfo2 const & ) const = default; #else bool operator==( BufferMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -12140,24 +11626,6 @@ namespace VULKAN_HPP_NAMESPACE }; using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 const & bufferMemoryRequirementsInfo2 ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferMemoryRequirementsInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferMemoryRequirementsInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferMemoryRequirementsInfo2.buffer ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BufferOpaqueCaptureAddressCreateInfo { using NativeType = VkBufferOpaqueCaptureAddressCreateInfo; @@ -12204,27 +11672,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBufferOpaqueCaptureAddressCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBufferOpaqueCaptureAddressCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBufferOpaqueCaptureAddressCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkBufferOpaqueCaptureAddressCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, opaqueCaptureAddress ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferOpaqueCaptureAddressCreateInfo const & ) const = default; #else bool operator==( BufferOpaqueCaptureAddressCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferOpaqueCaptureAddressCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -12249,24 +11727,6 @@ namespace VULKAN_HPP_NAMESPACE }; using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo const & - bufferOpaqueCaptureAddressCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferOpaqueCaptureAddressCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferOpaqueCaptureAddressCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, bufferOpaqueCaptureAddressCreateInfo.opaqueCaptureAddress ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct BufferViewCreateInfo { using NativeType = VkBufferViewCreateInfo; @@ -12344,28 +11804,43 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkBufferViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkBufferViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkBufferViewCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkBufferViewCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, buffer, format, offset, range ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferViewCreateInfo const & ) const = default; #else bool operator==( BufferViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( buffer == rhs.buffer ) && - ( format == rhs.format ) && ( offset == rhs.offset ) && ( range == rhs.range ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -12391,28 +11866,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = BufferViewCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & bufferViewCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, bufferViewCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, bufferViewCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferViewCreateFlags, seed, bufferViewCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, bufferViewCreateInfo.buffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, bufferViewCreateInfo.format ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferViewCreateInfo.offset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, bufferViewCreateInfo.range ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CalibratedTimestampInfoEXT { using NativeType = VkCalibratedTimestampInfoEXT; @@ -12458,27 +11911,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCalibratedTimestampInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCalibratedTimestampInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCalibratedTimestampInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkCalibratedTimestampInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, timeDomain ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CalibratedTimestampInfoEXT const & ) const = default; #else bool operator==( CalibratedTimestampInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timeDomain == rhs.timeDomain ); + return this->reflect() == rhs.reflect(); } bool operator!=( CalibratedTimestampInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -12501,24 +11966,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CalibratedTimestampInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT const & calibratedTimestampInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, calibratedTimestampInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, calibratedTimestampInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::TimeDomainEXT, seed, calibratedTimestampInfoEXT.timeDomain ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CheckpointData2NV { using NativeType = VkCheckpointData2NV; @@ -12548,28 +11995,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkCheckpointData2NV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCheckpointData2NV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCheckpointData2NV &() VULKAN_HPP_NOEXCEPT + explicit operator VkCheckpointData2NV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stage, pCheckpointMarker ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CheckpointData2NV const & ) const = default; #else bool operator==( CheckpointData2NV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) && - ( pCheckpointMarker == rhs.pCheckpointMarker ); + return this->reflect() == rhs.reflect(); } bool operator!=( CheckpointData2NV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -12592,24 +12051,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CheckpointData2NV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointData2NV const & checkpointData2NV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, checkpointData2NV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, checkpointData2NV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, checkpointData2NV.stage ); - VULKAN_HPP_HASH_COMBINE( void *, seed, checkpointData2NV.pCheckpointMarker ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CheckpointDataNV { using NativeType = VkCheckpointDataNV; @@ -12640,28 +12081,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkCheckpointDataNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCheckpointDataNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCheckpointDataNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkCheckpointDataNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stage, pCheckpointMarker ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CheckpointDataNV const & ) const = default; #else bool operator==( CheckpointDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) && - ( pCheckpointMarker == rhs.pCheckpointMarker ); + return this->reflect() == rhs.reflect(); } bool operator!=( CheckpointDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -12684,24 +12137,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CheckpointDataNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointDataNV const & checkpointDataNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, checkpointDataNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, checkpointDataNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits, seed, checkpointDataNV.stage ); - VULKAN_HPP_HASH_COMBINE( void *, seed, checkpointDataNV.pCheckpointMarker ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ union ClearColorValue { using NativeType = VkClearColorValue; @@ -12788,27 +12223,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkClearDepthStencilValue const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkClearDepthStencilValue const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkClearDepthStencilValue &() VULKAN_HPP_NOEXCEPT + explicit operator VkClearDepthStencilValue &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( depth, stencil ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ClearDepthStencilValue const & ) const = default; #else bool operator==( ClearDepthStencilValue const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( depth == rhs.depth ) && ( stencil == rhs.stencil ); + return this->reflect() == rhs.reflect(); } bool operator!=( ClearDepthStencilValue const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -12824,23 +12269,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ClearDepthStencilValue is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue const & clearDepthStencilValue ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( float, seed, clearDepthStencilValue.depth ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, clearDepthStencilValue.stencil ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ union ClearValue { using NativeType = VkClearValue; @@ -12938,16 +12366,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkClearAttachment const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkClearAttachment const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkClearAttachment &() VULKAN_HPP_NOEXCEPT + explicit operator VkClearAttachment &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std:: + tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( aspectMask, colorAttachment, clearValue ); + } + public: VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask = {}; uint32_t colorAttachment = {}; @@ -13007,27 +12446,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkClearRect const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkClearRect const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkClearRect &() VULKAN_HPP_NOEXCEPT + explicit operator VkClearRect &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( rect, baseArrayLayer, layerCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ClearRect const & ) const = default; #else - bool operator==( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( rect == rhs.rect ) && ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -13043,23 +12492,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ClearRect is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearRect const & clearRect ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, clearRect.rect ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, clearRect.baseArrayLayer ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, clearRect.layerCount ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CoarseSampleLocationNV { using NativeType = VkCoarseSampleLocationNV; @@ -13107,27 +12539,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCoarseSampleLocationNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCoarseSampleLocationNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCoarseSampleLocationNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkCoarseSampleLocationNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( pixelX, pixelY, sample ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CoarseSampleLocationNV const & ) const = default; #else bool operator==( CoarseSampleLocationNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( pixelX == rhs.pixelX ) && ( pixelY == rhs.pixelY ) && ( sample == rhs.sample ); + return this->reflect() == rhs.reflect(); } bool operator!=( CoarseSampleLocationNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -13144,24 +12586,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "CoarseSampleLocationNV is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV const & coarseSampleLocationNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleLocationNV.pixelX ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleLocationNV.pixelY ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleLocationNV.sample ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CoarseSampleOrderCustomNV { using NativeType = VkCoarseSampleOrderCustomNV; @@ -13248,28 +12672,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCoarseSampleOrderCustomNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCoarseSampleOrderCustomNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCoarseSampleOrderCustomNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkCoarseSampleOrderCustomNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( shadingRate, sampleCount, sampleLocationCount, pSampleLocations ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CoarseSampleOrderCustomNV const & ) const = default; #else bool operator==( CoarseSampleOrderCustomNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( shadingRate == rhs.shadingRate ) && ( sampleCount == rhs.sampleCount ) && - ( sampleLocationCount == rhs.sampleLocationCount ) && ( pSampleLocations == rhs.pSampleLocations ); + return this->reflect() == rhs.reflect(); } bool operator!=( CoarseSampleOrderCustomNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -13288,27 +12724,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "CoarseSampleOrderCustomNV is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV const & coarseSampleOrderCustomNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV, seed, coarseSampleOrderCustomNV.shadingRate ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleOrderCustomNV.sampleCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, coarseSampleOrderCustomNV.sampleLocationCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV *, seed, coarseSampleOrderCustomNV.pSampleLocations ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CommandBufferAllocateInfo { using NativeType = VkCommandBufferAllocateInfo; @@ -13371,28 +12786,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCommandBufferAllocateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCommandBufferAllocateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCommandBufferAllocateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkCommandBufferAllocateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, commandPool, level, commandBufferCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferAllocateInfo const & ) const = default; #else bool operator==( CommandBufferAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandPool == rhs.commandPool ) && - ( level == rhs.level ) && ( commandBufferCount == rhs.commandBufferCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( CommandBufferAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -13417,26 +12845,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CommandBufferAllocateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & commandBufferAllocateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferAllocateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferAllocateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandPool, seed, commandBufferAllocateInfo.commandPool ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandBufferLevel, seed, commandBufferAllocateInfo.level ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferAllocateInfo.commandBufferCount ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CommandBufferInheritanceInfo { using NativeType = VkCommandBufferInheritanceInfo; @@ -13525,30 +12933,45 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCommandBufferInheritanceInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCommandBufferInheritanceInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCommandBufferInheritanceInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkCommandBufferInheritanceInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, renderPass, subpass, framebuffer, occlusionQueryEnable, queryFlags, pipelineStatistics ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferInheritanceInfo const & ) const = default; #else bool operator==( CommandBufferInheritanceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) && - ( subpass == rhs.subpass ) && ( framebuffer == rhs.framebuffer ) && - ( occlusionQueryEnable == rhs.occlusionQueryEnable ) && ( queryFlags == rhs.queryFlags ) && - ( pipelineStatistics == rhs.pipelineStatistics ); + return this->reflect() == rhs.reflect(); } bool operator!=( CommandBufferInheritanceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -13577,30 +13000,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CommandBufferInheritanceInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( - VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo const & commandBufferInheritanceInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferInheritanceInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPass, seed, commandBufferInheritanceInfo.renderPass ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferInheritanceInfo.subpass ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Framebuffer, seed, commandBufferInheritanceInfo.framebuffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, commandBufferInheritanceInfo.occlusionQueryEnable ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueryControlFlags, seed, commandBufferInheritanceInfo.queryFlags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags, seed, commandBufferInheritanceInfo.pipelineStatistics ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CommandBufferBeginInfo { using NativeType = VkCommandBufferBeginInfo; @@ -13653,28 +13052,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCommandBufferBeginInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkCommandBufferBeginInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pInheritanceInfo ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferBeginInfo const & ) const = default; #else bool operator==( CommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( pInheritanceInfo == rhs.pInheritanceInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( CommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -13698,26 +13109,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CommandBufferBeginInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo const & commandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferBeginInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferBeginInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandBufferUsageFlags, seed, commandBufferBeginInfo.flags ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo *, seed, commandBufferBeginInfo.pInheritanceInfo ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CommandBufferInheritanceConditionalRenderingInfoEXT { using NativeType = VkCommandBufferInheritanceConditionalRenderingInfoEXT; @@ -13769,28 +13160,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCommandBufferInheritanceConditionalRenderingInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkCommandBufferInheritanceConditionalRenderingInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, conditionalRenderingEnable ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferInheritanceConditionalRenderingInfoEXT const & ) const = default; #else bool operator==( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( conditionalRenderingEnable == rhs.conditionalRenderingEnable ); + return this->reflect() == rhs.reflect(); } bool operator!=( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -13815,27 +13215,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CommandBufferInheritanceConditionalRenderingInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT const & - commandBufferInheritanceConditionalRenderingInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceConditionalRenderingInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferInheritanceConditionalRenderingInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - commandBufferInheritanceConditionalRenderingInfoEXT.conditionalRenderingEnable ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CommandBufferInheritanceRenderPassTransformInfoQCOM { using NativeType = VkCommandBufferInheritanceRenderPassTransformInfoQCOM; @@ -13897,28 +13276,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM &() VULKAN_HPP_NOEXCEPT + explicit operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, transform, renderArea ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferInheritanceRenderPassTransformInfoQCOM const & ) const = default; #else bool operator==( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ) && - ( renderArea == rhs.renderArea ); + return this->reflect() == rhs.reflect(); } bool operator!=( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -13945,29 +13336,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CommandBufferInheritanceRenderPassTransformInfoQCOM; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM const & - commandBufferInheritanceRenderPassTransformInfoQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceRenderPassTransformInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, commandBufferInheritanceRenderPassTransformInfoQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, - seed, - commandBufferInheritanceRenderPassTransformInfoQCOM.transform ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Rect2D, seed, commandBufferInheritanceRenderPassTransformInfoQCOM.renderArea ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CommandBufferInheritanceRenderingInfoKHR { using NativeType = VkCommandBufferInheritanceRenderingInfoKHR; @@ -14102,32 +13470,53 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCommandBufferInheritanceRenderingInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCommandBufferInheritanceRenderingInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCommandBufferInheritanceRenderingInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkCommandBufferInheritanceRenderingInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + viewMask, + colorAttachmentCount, + pColorAttachmentFormats, + depthAttachmentFormat, + stencilAttachmentFormat, + rasterizationSamples ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferInheritanceRenderingInfoKHR const & ) const = default; #else bool operator==( CommandBufferInheritanceRenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( viewMask == rhs.viewMask ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && - ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) && - ( depthAttachmentFormat == rhs.depthAttachmentFormat ) && - ( stencilAttachmentFormat == rhs.stencilAttachmentFormat ) && - ( rasterizationSamples == rhs.rasterizationSamples ); + return this->reflect() == rhs.reflect(); } bool operator!=( CommandBufferInheritanceRenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -14158,36 +13547,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CommandBufferInheritanceRenderingInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfoKHR const & - commandBufferInheritanceRenderingInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceRenderingInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferInheritanceRenderingInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::RenderingFlagsKHR, seed, commandBufferInheritanceRenderingInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferInheritanceRenderingInfoKHR.viewMask ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferInheritanceRenderingInfoKHR.colorAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::Format *, seed, commandBufferInheritanceRenderingInfoKHR.pColorAttachmentFormats ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Format, seed, commandBufferInheritanceRenderingInfoKHR.depthAttachmentFormat ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Format, seed, commandBufferInheritanceRenderingInfoKHR.stencilAttachmentFormat ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, commandBufferInheritanceRenderingInfoKHR.rasterizationSamples ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct Viewport { using NativeType = VkViewport; @@ -14258,28 +13617,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkViewport const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkViewport const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkViewport &() VULKAN_HPP_NOEXCEPT + explicit operator VkViewport &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y, width, height, minDepth, maxDepth ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Viewport const & ) const = default; #else bool operator==( Viewport const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( x == rhs.x ) && ( y == rhs.y ) && ( width == rhs.width ) && ( height == rhs.height ) && - ( minDepth == rhs.minDepth ) && ( maxDepth == rhs.maxDepth ); + return this->reflect() == rhs.reflect(); } bool operator!=( Viewport const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -14298,26 +13666,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Viewport is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::Viewport const & viewport ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( float, seed, viewport.x ); - VULKAN_HPP_HASH_COMBINE( float, seed, viewport.y ); - VULKAN_HPP_HASH_COMBINE( float, seed, viewport.width ); - VULKAN_HPP_HASH_COMBINE( float, seed, viewport.height ); - VULKAN_HPP_HASH_COMBINE( float, seed, viewport.minDepth ); - VULKAN_HPP_HASH_COMBINE( float, seed, viewport.maxDepth ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CommandBufferInheritanceViewportScissorInfoNV { using NativeType = VkCommandBufferInheritanceViewportScissorInfoNV; @@ -14386,28 +13734,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCommandBufferInheritanceViewportScissorInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCommandBufferInheritanceViewportScissorInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCommandBufferInheritanceViewportScissorInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkCommandBufferInheritanceViewportScissorInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, viewportScissor2D, viewportDepthCount, pViewportDepths ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferInheritanceViewportScissorInfoNV const & ) const = default; #else bool operator==( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewportScissor2D == rhs.viewportScissor2D ) && - ( viewportDepthCount == rhs.viewportDepthCount ) && ( pViewportDepths == rhs.pViewportDepths ); + return this->reflect() == rhs.reflect(); } bool operator!=( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -14434,29 +13795,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CommandBufferInheritanceViewportScissorInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV const & - commandBufferInheritanceViewportScissorInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferInheritanceViewportScissorInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferInheritanceViewportScissorInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, commandBufferInheritanceViewportScissorInfoNV.viewportScissor2D ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferInheritanceViewportScissorInfoNV.viewportDepthCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::Viewport *, seed, commandBufferInheritanceViewportScissorInfoNV.pViewportDepths ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CommandBufferSubmitInfoKHR { using NativeType = VkCommandBufferSubmitInfoKHR; @@ -14508,28 +13846,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCommandBufferSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCommandBufferSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCommandBufferSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkCommandBufferSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, commandBuffer, deviceMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferSubmitInfoKHR const & ) const = default; #else bool operator==( CommandBufferSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandBuffer == rhs.commandBuffer ) && - ( deviceMask == rhs.deviceMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( CommandBufferSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -14553,25 +13903,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CommandBufferSubmitInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfoKHR const & commandBufferSubmitInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandBufferSubmitInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, commandBufferSubmitInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandBuffer, seed, commandBufferSubmitInfoKHR.commandBuffer ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandBufferSubmitInfoKHR.deviceMask ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CommandPoolCreateInfo { using NativeType = VkCommandPoolCreateInfo; @@ -14623,28 +13954,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCommandPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCommandPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCommandPoolCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkCommandPoolCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, queueFamilyIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandPoolCreateInfo const & ) const = default; #else bool operator==( CommandPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( queueFamilyIndex == rhs.queueFamilyIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( CommandPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -14667,25 +14010,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CommandPoolCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & commandPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, commandPoolCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, commandPoolCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CommandPoolCreateFlags, seed, commandPoolCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, commandPoolCreateInfo.queueFamilyIndex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SpecializationMapEntry { using NativeType = VkSpecializationMapEntry; @@ -14733,27 +14057,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSpecializationMapEntry const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSpecializationMapEntry const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSpecializationMapEntry &() VULKAN_HPP_NOEXCEPT + explicit operator VkSpecializationMapEntry &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( constantID, offset, size ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SpecializationMapEntry const & ) const = default; #else bool operator==( SpecializationMapEntry const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( constantID == rhs.constantID ) && ( offset == rhs.offset ) && ( size == rhs.size ); + return this->reflect() == rhs.reflect(); } bool operator!=( SpecializationMapEntry const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -14770,24 +14104,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SpecializationMapEntry is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SpecializationMapEntry const & specializationMapEntry ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, specializationMapEntry.constantID ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, specializationMapEntry.offset ); - VULKAN_HPP_HASH_COMBINE( size_t, seed, specializationMapEntry.size ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SpecializationInfo { using NativeType = VkSpecializationInfo; @@ -14879,28 +14195,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSpecializationInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSpecializationInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSpecializationInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkSpecializationInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( mapEntryCount, pMapEntries, dataSize, pData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SpecializationInfo const & ) const = default; #else bool operator==( SpecializationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( mapEntryCount == rhs.mapEntryCount ) && ( pMapEntries == rhs.pMapEntries ) && - ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); + return this->reflect() == rhs.reflect(); } bool operator!=( SpecializationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -14917,26 +14245,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SpecializationInfo is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SpecializationInfo const & specializationInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, specializationInfo.mapEntryCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::SpecializationMapEntry *, seed, specializationInfo.pMapEntries ); - VULKAN_HPP_HASH_COMBINE( size_t, seed, specializationInfo.dataSize ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, specializationInfo.pData ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineShaderStageCreateInfo { using NativeType = VkPipelineShaderStageCreateInfo; @@ -15017,28 +14325,43 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineShaderStageCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineShaderStageCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineShaderStageCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineShaderStageCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, stage, module, pName, pSpecializationInfo ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineShaderStageCreateInfo const & ) const = default; #else bool operator==( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) && - ( module == rhs.module ) && ( pName == rhs.pName ) && ( pSpecializationInfo == rhs.pSpecializationInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -15066,30 +14389,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineShaderStageCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const & pipelineShaderStageCreateInfo ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineShaderStageCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineShaderStageCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateFlags, seed, pipelineShaderStageCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlagBits, seed, pipelineShaderStageCreateInfo.stage ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderModule, seed, pipelineShaderStageCreateInfo.module ); - VULKAN_HPP_HASH_COMBINE( const char *, seed, pipelineShaderStageCreateInfo.pName ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::SpecializationInfo *, seed, pipelineShaderStageCreateInfo.pSpecializationInfo ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ComputePipelineCreateInfo { using NativeType = VkComputePipelineCreateInfo; @@ -15169,29 +14468,43 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkComputePipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkComputePipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkComputePipelineCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkComputePipelineCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, stage, layout, basePipelineHandle, basePipelineIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ComputePipelineCreateInfo const & ) const = default; #else bool operator==( ComputePipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) && - ( layout == rhs.layout ) && ( basePipelineHandle == rhs.basePipelineHandle ) && - ( basePipelineIndex == rhs.basePipelineIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( ComputePipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -15218,29 +14531,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ComputePipelineCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & computePipelineCreateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, computePipelineCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, computePipelineCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreateFlags, seed, computePipelineCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo, seed, computePipelineCreateInfo.stage ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayout, seed, computePipelineCreateInfo.layout ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, computePipelineCreateInfo.basePipelineHandle ); - VULKAN_HPP_HASH_COMBINE( int32_t, seed, computePipelineCreateInfo.basePipelineIndex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ConditionalRenderingBeginInfoEXT { using NativeType = VkConditionalRenderingBeginInfoEXT; @@ -15304,28 +14594,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkConditionalRenderingBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkConditionalRenderingBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkConditionalRenderingBeginInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkConditionalRenderingBeginInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer, offset, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ConditionalRenderingBeginInfoEXT const & ) const = default; #else bool operator==( ConditionalRenderingBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && - ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( ConditionalRenderingBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -15351,28 +14654,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ConditionalRenderingBeginInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT const & conditionalRenderingBeginInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, conditionalRenderingBeginInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, conditionalRenderingBeginInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, conditionalRenderingBeginInfoEXT.buffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, conditionalRenderingBeginInfoEXT.offset ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ConditionalRenderingFlagsEXT, seed, conditionalRenderingBeginInfoEXT.flags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ConformanceVersion { using NativeType = VkConformanceVersion; @@ -15429,27 +14710,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkConformanceVersion const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkConformanceVersion const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkConformanceVersion &() VULKAN_HPP_NOEXCEPT + explicit operator VkConformanceVersion &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( major, minor, subminor, patch ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ConformanceVersion const & ) const = default; #else bool operator==( ConformanceVersion const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( major == rhs.major ) && ( minor == rhs.minor ) && ( subminor == rhs.subminor ) && ( patch == rhs.patch ); + return this->reflect() == rhs.reflect(); } bool operator!=( ConformanceVersion const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -15467,25 +14758,6 @@ namespace VULKAN_HPP_NAMESPACE "ConformanceVersion is not nothrow_move_constructible!" ); using ConformanceVersionKHR = ConformanceVersion; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ConformanceVersion const & conformanceVersion ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, conformanceVersion.major ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, conformanceVersion.minor ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, conformanceVersion.subminor ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, conformanceVersion.patch ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CooperativeMatrixPropertiesNV { using NativeType = VkCooperativeMatrixPropertiesNV; @@ -15591,29 +14863,46 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCooperativeMatrixPropertiesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkCooperativeMatrixPropertiesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, MSize, NSize, KSize, AType, BType, CType, DType, scope ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CooperativeMatrixPropertiesNV const & ) const = default; #else bool operator==( CooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( MSize == rhs.MSize ) && ( NSize == rhs.NSize ) && - ( KSize == rhs.KSize ) && ( AType == rhs.AType ) && ( BType == rhs.BType ) && ( CType == rhs.CType ) && - ( DType == rhs.DType ) && ( scope == rhs.scope ); + return this->reflect() == rhs.reflect(); } bool operator!=( CooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -15644,31 +14933,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CooperativeMatrixPropertiesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV const & cooperativeMatrixPropertiesNV ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, cooperativeMatrixPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, cooperativeMatrixPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cooperativeMatrixPropertiesNV.MSize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cooperativeMatrixPropertiesNV.NSize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cooperativeMatrixPropertiesNV.KSize ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentTypeNV, seed, cooperativeMatrixPropertiesNV.AType ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentTypeNV, seed, cooperativeMatrixPropertiesNV.BType ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentTypeNV, seed, cooperativeMatrixPropertiesNV.CType ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentTypeNV, seed, cooperativeMatrixPropertiesNV.DType ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ScopeNV, seed, cooperativeMatrixPropertiesNV.scope ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CopyAccelerationStructureInfoKHR { using NativeType = VkCopyAccelerationStructureInfoKHR; @@ -15733,28 +14997,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCopyAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCopyAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCopyAccelerationStructureInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkCopyAccelerationStructureInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, src, dst, mode ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyAccelerationStructureInfoKHR const & ) const = default; #else bool operator==( CopyAccelerationStructureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( src == rhs.src ) && ( dst == rhs.dst ) && - ( mode == rhs.mode ); + return this->reflect() == rhs.reflect(); } bool operator!=( CopyAccelerationStructureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -15781,30 +15058,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CopyAccelerationStructureInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR const & copyAccelerationStructureInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyAccelerationStructureInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, copyAccelerationStructureInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, seed, copyAccelerationStructureInfoKHR.src ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, seed, copyAccelerationStructureInfoKHR.dst ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR, seed, copyAccelerationStructureInfoKHR.mode ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CopyAccelerationStructureToMemoryInfoKHR { using NativeType = VkCopyAccelerationStructureToMemoryInfoKHR; @@ -15874,16 +15127,30 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCopyAccelerationStructureToMemoryInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCopyAccelerationStructureToMemoryInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCopyAccelerationStructureToMemoryInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkCopyAccelerationStructureToMemoryInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, src, dst, mode ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCopyAccelerationStructureToMemoryInfoKHR; const void * pNext = {}; @@ -16000,28 +15267,42 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCopyBufferInfo2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCopyBufferInfo2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCopyBufferInfo2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkCopyBufferInfo2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcBuffer, dstBuffer, regionCount, pRegions ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyBufferInfo2KHR const & ) const = default; #else bool operator==( CopyBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) && - ( dstBuffer == rhs.dstBuffer ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); + return this->reflect() == rhs.reflect(); } bool operator!=( CopyBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -16046,27 +15327,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CopyBufferInfo2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR const & copyBufferInfo2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyBufferInfo2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, copyBufferInfo2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, copyBufferInfo2KHR.srcBuffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, copyBufferInfo2KHR.dstBuffer ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyBufferInfo2KHR.regionCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::BufferCopy2KHR *, seed, copyBufferInfo2KHR.pRegions ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CopyBufferToImageInfo2KHR { using NativeType = VkCopyBufferToImageInfo2KHR; @@ -16171,29 +15431,43 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCopyBufferToImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCopyBufferToImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCopyBufferToImageInfo2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkCopyBufferToImageInfo2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyBufferToImageInfo2KHR const & ) const = default; #else bool operator==( CopyBufferToImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) && - ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) && - ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); + return this->reflect() == rhs.reflect(); } bool operator!=( CopyBufferToImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -16220,29 +15494,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CopyBufferToImageInfo2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR const & copyBufferToImageInfo2KHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyBufferToImageInfo2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, copyBufferToImageInfo2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, copyBufferToImageInfo2KHR.srcBuffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, copyBufferToImageInfo2KHR.dstImage ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, copyBufferToImageInfo2KHR.dstImageLayout ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyBufferToImageInfo2KHR.regionCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR *, seed, copyBufferToImageInfo2KHR.pRegions ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CopyCommandTransformInfoQCOM { using NativeType = VkCopyCommandTransformInfoQCOM; @@ -16288,27 +15539,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCopyCommandTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCopyCommandTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCopyCommandTransformInfoQCOM &() VULKAN_HPP_NOEXCEPT + explicit operator VkCopyCommandTransformInfoQCOM &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, transform ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyCommandTransformInfoQCOM const & ) const = default; #else bool operator==( CopyCommandTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ); + return this->reflect() == rhs.reflect(); } bool operator!=( CopyCommandTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -16333,25 +15596,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CopyCommandTransformInfoQCOM; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( - VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM const & copyCommandTransformInfoQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyCommandTransformInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, copyCommandTransformInfoQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, copyCommandTransformInfoQCOM.transform ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CopyDescriptorSet { using NativeType = VkCopyDescriptorSet; @@ -16443,30 +15687,46 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCopyDescriptorSet const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCopyDescriptorSet const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCopyDescriptorSet &() VULKAN_HPP_NOEXCEPT + explicit operator VkCopyDescriptorSet &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, srcSet, srcBinding, srcArrayElement, dstSet, dstBinding, dstArrayElement, descriptorCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyDescriptorSet const & ) const = default; #else bool operator==( CopyDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSet == rhs.srcSet ) && - ( srcBinding == rhs.srcBinding ) && ( srcArrayElement == rhs.srcArrayElement ) && - ( dstSet == rhs.dstSet ) && ( dstBinding == rhs.dstBinding ) && - ( dstArrayElement == rhs.dstArrayElement ) && ( descriptorCount == rhs.descriptorCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( CopyDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -16494,29 +15754,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CopyDescriptorSet; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyDescriptorSet const & copyDescriptorSet ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyDescriptorSet.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, copyDescriptorSet.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorSet, seed, copyDescriptorSet.srcSet ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.srcBinding ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.srcArrayElement ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorSet, seed, copyDescriptorSet.dstSet ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.dstBinding ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.dstArrayElement ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyDescriptorSet.descriptorCount ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageCopy2KHR { using NativeType = VkImageCopy2KHR; @@ -16595,29 +15832,43 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageCopy2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageCopy2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageCopy2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageCopy2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageCopy2KHR const & ) const = default; #else bool operator==( ImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && - ( srcOffset == rhs.srcOffset ) && ( dstSubresource == rhs.dstSubresource ) && - ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -16643,27 +15894,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImageCopy2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy2KHR const & imageCopy2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageCopy2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageCopy2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageCopy2KHR.srcSubresource ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageCopy2KHR.srcOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageCopy2KHR.dstSubresource ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageCopy2KHR.dstOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageCopy2KHR.extent ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CopyImageInfo2KHR { using NativeType = VkCopyImageInfo2KHR; @@ -16776,30 +16006,44 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCopyImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCopyImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCopyImageInfo2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkCopyImageInfo2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyImageInfo2KHR const & ) const = default; #else bool operator==( CopyImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && - ( srcImageLayout == rhs.srcImageLayout ) && ( dstImage == rhs.dstImage ) && - ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && - ( pRegions == rhs.pRegions ); + return this->reflect() == rhs.reflect(); } bool operator!=( CopyImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -16826,28 +16070,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CopyImageInfo2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR const & copyImageInfo2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyImageInfo2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, copyImageInfo2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, copyImageInfo2KHR.srcImage ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, copyImageInfo2KHR.srcImageLayout ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, copyImageInfo2KHR.dstImage ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, copyImageInfo2KHR.dstImageLayout ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyImageInfo2KHR.regionCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageCopy2KHR *, seed, copyImageInfo2KHR.pRegions ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CopyImageToBufferInfo2KHR { using NativeType = VkCopyImageToBufferInfo2KHR; @@ -16952,29 +16174,43 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCopyImageToBufferInfo2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCopyImageToBufferInfo2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCopyImageToBufferInfo2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkCopyImageToBufferInfo2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyImageToBufferInfo2KHR const & ) const = default; #else bool operator==( CopyImageToBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && - ( srcImageLayout == rhs.srcImageLayout ) && ( dstBuffer == rhs.dstBuffer ) && - ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); + return this->reflect() == rhs.reflect(); } bool operator!=( CopyImageToBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -17001,29 +16237,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CopyImageToBufferInfo2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR const & copyImageToBufferInfo2KHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, copyImageToBufferInfo2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, copyImageToBufferInfo2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, copyImageToBufferInfo2KHR.srcImage ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, copyImageToBufferInfo2KHR.srcImageLayout ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, copyImageToBufferInfo2KHR.dstBuffer ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, copyImageToBufferInfo2KHR.regionCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR *, seed, copyImageToBufferInfo2KHR.pRegions ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CopyMemoryToAccelerationStructureInfoKHR { using NativeType = VkCopyMemoryToAccelerationStructureInfoKHR; @@ -17093,16 +16306,30 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCopyMemoryToAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCopyMemoryToAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCopyMemoryToAccelerationStructureInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkCopyMemoryToAccelerationStructureInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, src, dst, mode ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCopyMemoryToAccelerationStructureInfoKHR; const void * pNext = {}; @@ -17177,27 +16404,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCuFunctionCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCuFunctionCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCuFunctionCreateInfoNVX &() VULKAN_HPP_NOEXCEPT + explicit operator VkCuFunctionCreateInfoNVX &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, module, pName ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CuFunctionCreateInfoNVX const & ) const = default; #else bool operator==( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( module == rhs.module ) && ( pName == rhs.pName ); + return this->reflect() == rhs.reflect(); } bool operator!=( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -17221,25 +16461,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CuFunctionCreateInfoNVX; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & cuFunctionCreateInfoNVX ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, cuFunctionCreateInfoNVX.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, cuFunctionCreateInfoNVX.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CuModuleNVX, seed, cuFunctionCreateInfoNVX.module ); - VULKAN_HPP_HASH_COMBINE( const char *, seed, cuFunctionCreateInfoNVX.pName ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CuLaunchInfoNVX { using NativeType = VkCuLaunchInfoNVX; @@ -17416,31 +16637,63 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCuLaunchInfoNVX const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCuLaunchInfoNVX const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCuLaunchInfoNVX &() VULKAN_HPP_NOEXCEPT + explicit operator VkCuLaunchInfoNVX &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + function, + gridDimX, + gridDimY, + gridDimZ, + blockDimX, + blockDimY, + blockDimZ, + sharedMemBytes, + paramCount, + pParams, + extraCount, + pExtras ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CuLaunchInfoNVX const & ) const = default; #else bool operator==( CuLaunchInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( function == rhs.function ) && - ( gridDimX == rhs.gridDimX ) && ( gridDimY == rhs.gridDimY ) && ( gridDimZ == rhs.gridDimZ ) && - ( blockDimX == rhs.blockDimX ) && ( blockDimY == rhs.blockDimY ) && ( blockDimZ == rhs.blockDimZ ) && - ( sharedMemBytes == rhs.sharedMemBytes ) && ( paramCount == rhs.paramCount ) && - ( pParams == rhs.pParams ) && ( extraCount == rhs.extraCount ) && ( pExtras == rhs.pExtras ); + return this->reflect() == rhs.reflect(); } bool operator!=( CuLaunchInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -17473,34 +16726,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CuLaunchInfoNVX; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX const & cuLaunchInfoNVX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, cuLaunchInfoNVX.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, cuLaunchInfoNVX.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CuFunctionNVX, seed, cuLaunchInfoNVX.function ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.gridDimX ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.gridDimY ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.gridDimZ ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.blockDimX ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.blockDimY ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.blockDimZ ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, cuLaunchInfoNVX.sharedMemBytes ); - VULKAN_HPP_HASH_COMBINE( size_t, seed, cuLaunchInfoNVX.paramCount ); - VULKAN_HPP_HASH_COMBINE( const void * const *, seed, cuLaunchInfoNVX.pParams ); - VULKAN_HPP_HASH_COMBINE( size_t, seed, cuLaunchInfoNVX.extraCount ); - VULKAN_HPP_HASH_COMBINE( const void * const *, seed, cuLaunchInfoNVX.pExtras ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct CuModuleCreateInfoNVX { using NativeType = VkCuModuleCreateInfoNVX; @@ -17567,27 +16792,37 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkCuModuleCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkCuModuleCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkCuModuleCreateInfoNVX &() VULKAN_HPP_NOEXCEPT + explicit operator VkCuModuleCreateInfoNVX &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dataSize, pData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CuModuleCreateInfoNVX const & ) const = default; #else bool operator==( CuModuleCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); + return this->reflect() == rhs.reflect(); } bool operator!=( CuModuleCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -17610,25 +16845,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = CuModuleCreateInfoNVX; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & cuModuleCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, cuModuleCreateInfoNVX.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, cuModuleCreateInfoNVX.pNext ); - VULKAN_HPP_HASH_COMBINE( size_t, seed, cuModuleCreateInfoNVX.dataSize ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, cuModuleCreateInfoNVX.pData ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_WIN32_KHR ) struct D3D12FenceSubmitInfoKHR { @@ -17730,31 +16946,47 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkD3D12FenceSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkD3D12FenceSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkD3D12FenceSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkD3D12FenceSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + waitSemaphoreValuesCount, + pWaitSemaphoreValues, + signalSemaphoreValuesCount, + pSignalSemaphoreValues ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( D3D12FenceSubmitInfoKHR const & ) const = default; # else bool operator==( D3D12FenceSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( waitSemaphoreValuesCount == rhs.waitSemaphoreValuesCount ) && - ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) && - ( signalSemaphoreValuesCount == rhs.signalSemaphoreValuesCount ) && - ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues ); + return this->reflect() == rhs.reflect(); } bool operator!=( D3D12FenceSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -17779,28 +17011,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = D3D12FenceSubmitInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR const & d3D12FenceSubmitInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, d3D12FenceSubmitInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, d3D12FenceSubmitInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, d3D12FenceSubmitInfoKHR.waitSemaphoreValuesCount ); - VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, d3D12FenceSubmitInfoKHR.pWaitSemaphoreValues ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, d3D12FenceSubmitInfoKHR.signalSemaphoreValuesCount ); - VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, d3D12FenceSubmitInfoKHR.pSignalSemaphoreValues ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct DebugMarkerMarkerInfoEXT @@ -17853,28 +17063,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDebugMarkerMarkerInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDebugMarkerMarkerInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDebugMarkerMarkerInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDebugMarkerMarkerInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pMarkerName, color ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugMarkerMarkerInfoEXT const & ) const = default; #else bool operator==( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pMarkerName == rhs.pMarkerName ) && - ( color == rhs.color ); + return this->reflect() == rhs.reflect(); } bool operator!=( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -17898,28 +17120,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DebugMarkerMarkerInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT const & debugMarkerMarkerInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugMarkerMarkerInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, debugMarkerMarkerInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( const char *, seed, debugMarkerMarkerInfoEXT.pMarkerName ); - for ( size_t i = 0; i < 4; ++i ) - { - VULKAN_HPP_HASH_COMBINE( float, seed, debugMarkerMarkerInfoEXT.color[i] ); - } - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DebugMarkerObjectNameInfoEXT { using NativeType = VkDebugMarkerObjectNameInfoEXT; @@ -17981,28 +17181,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDebugMarkerObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDebugMarkerObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDebugMarkerObjectNameInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDebugMarkerObjectNameInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, objectType, object, pObjectName ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugMarkerObjectNameInfoEXT const & ) const = default; #else bool operator==( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && - ( object == rhs.object ) && ( pObjectName == rhs.pObjectName ); + return this->reflect() == rhs.reflect(); } bool operator!=( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -18029,27 +17242,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DebugMarkerObjectNameInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( - VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT const & debugMarkerObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugMarkerObjectNameInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, debugMarkerObjectNameInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, seed, debugMarkerObjectNameInfoEXT.objectType ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugMarkerObjectNameInfoEXT.object ); - VULKAN_HPP_HASH_COMBINE( const char *, seed, debugMarkerObjectNameInfoEXT.pObjectName ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DebugMarkerObjectTagInfoEXT { using NativeType = VkDebugMarkerObjectTagInfoEXT; @@ -18151,29 +17343,43 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDebugMarkerObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDebugMarkerObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDebugMarkerObjectTagInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDebugMarkerObjectTagInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, objectType, object, tagName, tagSize, pTag ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugMarkerObjectTagInfoEXT const & ) const = default; #else bool operator==( DebugMarkerObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && - ( object == rhs.object ) && ( tagName == rhs.tagName ) && ( tagSize == rhs.tagSize ) && - ( pTag == rhs.pTag ); + return this->reflect() == rhs.reflect(); } bool operator!=( DebugMarkerObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -18202,29 +17408,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DebugMarkerObjectTagInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT const & debugMarkerObjectTagInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugMarkerObjectTagInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, debugMarkerObjectTagInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, seed, debugMarkerObjectTagInfoEXT.objectType ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugMarkerObjectTagInfoEXT.object ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugMarkerObjectTagInfoEXT.tagName ); - VULKAN_HPP_HASH_COMBINE( size_t, seed, debugMarkerObjectTagInfoEXT.tagSize ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, debugMarkerObjectTagInfoEXT.pTag ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DebugReportCallbackCreateInfoEXT { using NativeType = VkDebugReportCallbackCreateInfoEXT; @@ -18286,28 +17469,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDebugReportCallbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDebugReportCallbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDebugReportCallbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDebugReportCallbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pfnCallback, pUserData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugReportCallbackCreateInfoEXT const & ) const = default; #else bool operator==( DebugReportCallbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( pfnCallback == rhs.pfnCallback ) && ( pUserData == rhs.pUserData ); + return this->reflect() == rhs.reflect(); } bool operator!=( DebugReportCallbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -18333,27 +17529,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DebugReportCallbackCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & debugReportCallbackCreateInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugReportCallbackCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, debugReportCallbackCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT, seed, debugReportCallbackCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( PFN_vkDebugReportCallbackEXT, seed, debugReportCallbackCreateInfoEXT.pfnCallback ); - VULKAN_HPP_HASH_COMBINE( void *, seed, debugReportCallbackCreateInfoEXT.pUserData ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DebugUtilsLabelEXT { using NativeType = VkDebugUtilsLabelEXT; @@ -18403,28 +17578,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDebugUtilsLabelEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDebugUtilsLabelEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDebugUtilsLabelEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDebugUtilsLabelEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pLabelName, color ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugUtilsLabelEXT const & ) const = default; #else bool operator==( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pLabelName == rhs.pLabelName ) && - ( color == rhs.color ); + return this->reflect() == rhs.reflect(); } bool operator!=( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -18447,28 +17634,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DebugUtilsLabelEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT const & debugUtilsLabelEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsLabelEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsLabelEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( const char *, seed, debugUtilsLabelEXT.pLabelName ); - for ( size_t i = 0; i < 4; ++i ) - { - VULKAN_HPP_HASH_COMBINE( float, seed, debugUtilsLabelEXT.color[i] ); - } - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DebugUtilsObjectNameInfoEXT { using NativeType = VkDebugUtilsObjectNameInfoEXT; @@ -18530,28 +17695,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDebugUtilsObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDebugUtilsObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDebugUtilsObjectNameInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDebugUtilsObjectNameInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, objectType, objectHandle, pObjectName ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugUtilsObjectNameInfoEXT const & ) const = default; #else bool operator==( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && - ( objectHandle == rhs.objectHandle ) && ( pObjectName == rhs.pObjectName ); + return this->reflect() == rhs.reflect(); } bool operator!=( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -18577,26 +17755,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DebugUtilsObjectNameInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT const & debugUtilsObjectNameInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsObjectNameInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsObjectNameInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ObjectType, seed, debugUtilsObjectNameInfoEXT.objectType ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugUtilsObjectNameInfoEXT.objectHandle ); - VULKAN_HPP_HASH_COMBINE( const char *, seed, debugUtilsObjectNameInfoEXT.pObjectName ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DebugUtilsMessengerCallbackDataEXT { using NativeType = VkDebugUtilsMessengerCallbackDataEXT; @@ -18783,32 +17941,59 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDebugUtilsMessengerCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDebugUtilsMessengerCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDebugUtilsMessengerCallbackDataEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDebugUtilsMessengerCallbackDataEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + pMessageIdName, + messageIdNumber, + pMessage, + queueLabelCount, + pQueueLabels, + cmdBufLabelCount, + pCmdBufLabels, + objectCount, + pObjects ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugUtilsMessengerCallbackDataEXT const & ) const = default; #else bool operator==( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( pMessageIdName == rhs.pMessageIdName ) && ( messageIdNumber == rhs.messageIdNumber ) && - ( pMessage == rhs.pMessage ) && ( queueLabelCount == rhs.queueLabelCount ) && - ( pQueueLabels == rhs.pQueueLabels ) && ( cmdBufLabelCount == rhs.cmdBufLabelCount ) && - ( pCmdBufLabels == rhs.pCmdBufLabels ) && ( objectCount == rhs.objectCount ) && - ( pObjects == rhs.pObjects ); + return this->reflect() == rhs.reflect(); } bool operator!=( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -18841,37 +18026,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DebugUtilsMessengerCallbackDataEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT const & - debugUtilsMessengerCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsMessengerCallbackDataEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsMessengerCallbackDataEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataFlagsEXT, seed, debugUtilsMessengerCallbackDataEXT.flags ); - VULKAN_HPP_HASH_COMBINE( const char *, seed, debugUtilsMessengerCallbackDataEXT.pMessageIdName ); - VULKAN_HPP_HASH_COMBINE( int32_t, seed, debugUtilsMessengerCallbackDataEXT.messageIdNumber ); - VULKAN_HPP_HASH_COMBINE( const char *, seed, debugUtilsMessengerCallbackDataEXT.pMessage ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, debugUtilsMessengerCallbackDataEXT.queueLabelCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *, seed, debugUtilsMessengerCallbackDataEXT.pQueueLabels ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, debugUtilsMessengerCallbackDataEXT.cmdBufLabelCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *, seed, debugUtilsMessengerCallbackDataEXT.pCmdBufLabels ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, debugUtilsMessengerCallbackDataEXT.objectCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT *, seed, debugUtilsMessengerCallbackDataEXT.pObjects ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DebugUtilsMessengerCreateInfoEXT { using NativeType = VkDebugUtilsMessengerCreateInfoEXT; @@ -18952,29 +18106,43 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDebugUtilsMessengerCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDebugUtilsMessengerCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDebugUtilsMessengerCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDebugUtilsMessengerCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, messageSeverity, messageType, pfnUserCallback, pUserData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugUtilsMessengerCreateInfoEXT const & ) const = default; #else bool operator==( DebugUtilsMessengerCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( messageSeverity == rhs.messageSeverity ) && ( messageType == rhs.messageType ) && - ( pfnUserCallback == rhs.pfnUserCallback ) && ( pUserData == rhs.pUserData ); + return this->reflect() == rhs.reflect(); } bool operator!=( DebugUtilsMessengerCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -19002,33 +18170,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DebugUtilsMessengerCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & debugUtilsMessengerCreateInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsMessengerCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsMessengerCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT, seed, debugUtilsMessengerCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT, seed, debugUtilsMessengerCreateInfoEXT.messageSeverity ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT, seed, debugUtilsMessengerCreateInfoEXT.messageType ); - VULKAN_HPP_HASH_COMBINE( - PFN_vkDebugUtilsMessengerCallbackEXT, seed, debugUtilsMessengerCreateInfoEXT.pfnUserCallback ); - VULKAN_HPP_HASH_COMBINE( void *, seed, debugUtilsMessengerCreateInfoEXT.pUserData ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DebugUtilsObjectTagInfoEXT { using NativeType = VkDebugUtilsObjectTagInfoEXT; @@ -19130,29 +18271,43 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDebugUtilsObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDebugUtilsObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDebugUtilsObjectTagInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDebugUtilsObjectTagInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, objectType, objectHandle, tagName, tagSize, pTag ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugUtilsObjectTagInfoEXT const & ) const = default; #else bool operator==( DebugUtilsObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && - ( objectHandle == rhs.objectHandle ) && ( tagName == rhs.tagName ) && ( tagSize == rhs.tagSize ) && - ( pTag == rhs.pTag ); + return this->reflect() == rhs.reflect(); } bool operator!=( DebugUtilsObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -19179,28 +18334,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DebugUtilsObjectTagInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT const & debugUtilsObjectTagInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, debugUtilsObjectTagInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsObjectTagInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ObjectType, seed, debugUtilsObjectTagInfoEXT.objectType ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugUtilsObjectTagInfoEXT.objectHandle ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, debugUtilsObjectTagInfoEXT.tagName ); - VULKAN_HPP_HASH_COMBINE( size_t, seed, debugUtilsObjectTagInfoEXT.tagSize ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, debugUtilsObjectTagInfoEXT.pTag ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DedicatedAllocationBufferCreateInfoNV { using NativeType = VkDedicatedAllocationBufferCreateInfoNV; @@ -19248,27 +18381,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDedicatedAllocationBufferCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDedicatedAllocationBufferCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDedicatedAllocationBufferCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkDedicatedAllocationBufferCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dedicatedAllocation ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DedicatedAllocationBufferCreateInfoNV const & ) const = default; #else bool operator==( DedicatedAllocationBufferCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation ); + return this->reflect() == rhs.reflect(); } bool operator!=( DedicatedAllocationBufferCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -19292,25 +18435,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DedicatedAllocationBufferCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV const & - dedicatedAllocationBufferCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, dedicatedAllocationBufferCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, dedicatedAllocationBufferCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, dedicatedAllocationBufferCreateInfoNV.dedicatedAllocation ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DedicatedAllocationImageCreateInfoNV { using NativeType = VkDedicatedAllocationImageCreateInfoNV; @@ -19358,27 +18482,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDedicatedAllocationImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDedicatedAllocationImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDedicatedAllocationImageCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkDedicatedAllocationImageCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dedicatedAllocation ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DedicatedAllocationImageCreateInfoNV const & ) const = default; #else bool operator==( DedicatedAllocationImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation ); + return this->reflect() == rhs.reflect(); } bool operator!=( DedicatedAllocationImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -19402,25 +18536,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DedicatedAllocationImageCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV const & - dedicatedAllocationImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, dedicatedAllocationImageCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, dedicatedAllocationImageCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, dedicatedAllocationImageCreateInfoNV.dedicatedAllocation ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DedicatedAllocationMemoryAllocateInfoNV { using NativeType = VkDedicatedAllocationMemoryAllocateInfoNV; @@ -19479,27 +18594,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDedicatedAllocationMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDedicatedAllocationMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDedicatedAllocationMemoryAllocateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkDedicatedAllocationMemoryAllocateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image, buffer ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DedicatedAllocationMemoryAllocateInfoNV const & ) const = default; #else bool operator==( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer ); + return this->reflect() == rhs.reflect(); } bool operator!=( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -19525,25 +18653,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DedicatedAllocationMemoryAllocateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV const & - dedicatedAllocationMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, dedicatedAllocationMemoryAllocateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, dedicatedAllocationMemoryAllocateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, dedicatedAllocationMemoryAllocateInfoNV.image ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, dedicatedAllocationMemoryAllocateInfoNV.buffer ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MemoryBarrier2KHR { using NativeType = VkMemoryBarrier2KHR; @@ -19614,29 +18723,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryBarrier2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryBarrier2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcStageMask, srcAccessMask, dstStageMask, dstAccessMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryBarrier2KHR const & ) const = default; #else bool operator==( MemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && - ( srcAccessMask == rhs.srcAccessMask ) && ( dstStageMask == rhs.dstStageMask ) && - ( dstAccessMask == rhs.dstAccessMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -19661,26 +18783,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = MemoryBarrier2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier2KHR const & memoryBarrier2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryBarrier2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryBarrier2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, memoryBarrier2KHR.srcStageMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, memoryBarrier2KHR.srcAccessMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, memoryBarrier2KHR.dstStageMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, memoryBarrier2KHR.dstAccessMask ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageSubresourceRange { using NativeType = VkImageSubresourceRange; @@ -19746,29 +18848,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageSubresourceRange const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageSubresourceRange const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageSubresourceRange &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageSubresourceRange &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( aspectMask, baseMipLevel, levelCount, baseArrayLayer, layerCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageSubresourceRange const & ) const = default; #else bool operator==( ImageSubresourceRange const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( aspectMask == rhs.aspectMask ) && ( baseMipLevel == rhs.baseMipLevel ) && - ( levelCount == rhs.levelCount ) && ( baseArrayLayer == rhs.baseArrayLayer ) && - ( layerCount == rhs.layerCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageSubresourceRange const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -19786,26 +18900,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageSubresourceRange is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceRange const & imageSubresourceRange ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, imageSubresourceRange.aspectMask ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceRange.baseMipLevel ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceRange.levelCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceRange.baseArrayLayer ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageSubresourceRange.layerCount ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageMemoryBarrier2KHR { using NativeType = VkImageMemoryBarrier2KHR; @@ -19929,32 +19023,59 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageMemoryBarrier2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageMemoryBarrier2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageMemoryBarrier2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + srcStageMask, + srcAccessMask, + dstStageMask, + dstAccessMask, + oldLayout, + newLayout, + srcQueueFamilyIndex, + dstQueueFamilyIndex, + image, + subresourceRange ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageMemoryBarrier2KHR const & ) const = default; #else bool operator==( ImageMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && - ( srcAccessMask == rhs.srcAccessMask ) && ( dstStageMask == rhs.dstStageMask ) && - ( dstAccessMask == rhs.dstAccessMask ) && ( oldLayout == rhs.oldLayout ) && - ( newLayout == rhs.newLayout ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && - ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( image == rhs.image ) && - ( subresourceRange == rhs.subresourceRange ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -19986,34 +19107,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImageMemoryBarrier2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2KHR const & imageMemoryBarrier2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageMemoryBarrier2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageMemoryBarrier2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, imageMemoryBarrier2KHR.srcStageMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, imageMemoryBarrier2KHR.srcAccessMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, imageMemoryBarrier2KHR.dstStageMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags2KHR, seed, imageMemoryBarrier2KHR.dstAccessMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageMemoryBarrier2KHR.oldLayout ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageMemoryBarrier2KHR.newLayout ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageMemoryBarrier2KHR.srcQueueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageMemoryBarrier2KHR.dstQueueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageMemoryBarrier2KHR.image ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ImageSubresourceRange, seed, imageMemoryBarrier2KHR.subresourceRange ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DependencyInfoKHR { using NativeType = VkDependencyInfoKHR; @@ -20163,32 +19256,53 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDependencyInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDependencyInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDependencyInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDependencyInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + dependencyFlags, + memoryBarrierCount, + pMemoryBarriers, + bufferMemoryBarrierCount, + pBufferMemoryBarriers, + imageMemoryBarrierCount, + pImageMemoryBarriers ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DependencyInfoKHR const & ) const = default; #else bool operator==( DependencyInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dependencyFlags == rhs.dependencyFlags ) && - ( memoryBarrierCount == rhs.memoryBarrierCount ) && ( pMemoryBarriers == rhs.pMemoryBarriers ) && - ( bufferMemoryBarrierCount == rhs.bufferMemoryBarrierCount ) && - ( pBufferMemoryBarriers == rhs.pBufferMemoryBarriers ) && - ( imageMemoryBarrierCount == rhs.imageMemoryBarrierCount ) && - ( pImageMemoryBarriers == rhs.pImageMemoryBarriers ); + return this->reflect() == rhs.reflect(); } bool operator!=( DependencyInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -20216,31 +19330,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DependencyInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DependencyInfoKHR const & dependencyInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, dependencyInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, dependencyInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DependencyFlags, seed, dependencyInfoKHR.dependencyFlags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dependencyInfoKHR.memoryBarrierCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::MemoryBarrier2KHR *, seed, dependencyInfoKHR.pMemoryBarriers ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dependencyInfoKHR.bufferMemoryBarrierCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2KHR *, seed, dependencyInfoKHR.pBufferMemoryBarriers ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dependencyInfoKHR.imageMemoryBarrierCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2KHR *, seed, dependencyInfoKHR.pImageMemoryBarriers ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DescriptorBufferInfo { using NativeType = VkDescriptorBufferInfo; @@ -20291,27 +19380,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDescriptorBufferInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorBufferInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDescriptorBufferInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorBufferInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( buffer, offset, range ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorBufferInfo const & ) const = default; #else bool operator==( DescriptorBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( range == rhs.range ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -20327,24 +19428,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "DescriptorBufferInfo is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferInfo const & descriptorBufferInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, descriptorBufferInfo.buffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, descriptorBufferInfo.offset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, descriptorBufferInfo.range ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DescriptorImageInfo { using NativeType = VkDescriptorImageInfo; @@ -20397,27 +19480,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDescriptorImageInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorImageInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDescriptorImageInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorImageInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sampler, imageView, imageLayout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorImageInfo const & ) const = default; #else bool operator==( DescriptorImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sampler == rhs.sampler ) && ( imageView == rhs.imageView ) && ( imageLayout == rhs.imageLayout ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -20433,24 +19528,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "DescriptorImageInfo is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DescriptorImageInfo const & descriptorImageInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Sampler, seed, descriptorImageInfo.sampler ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageView, seed, descriptorImageInfo.imageView ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, descriptorImageInfo.imageLayout ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DescriptorPoolSize { using NativeType = VkDescriptorPoolSize; @@ -20493,27 +19570,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDescriptorPoolSize const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorPoolSize const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDescriptorPoolSize &() VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorPoolSize &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( type, descriptorCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorPoolSize const & ) const = default; #else bool operator==( DescriptorPoolSize const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( type == rhs.type ) && ( descriptorCount == rhs.descriptorCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorPoolSize const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -20528,23 +19615,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "DescriptorPoolSize is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolSize const & descriptorPoolSize ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, descriptorPoolSize.type ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorPoolSize.descriptorCount ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DescriptorPoolCreateInfo { using NativeType = VkDescriptorPoolCreateInfo; @@ -20636,28 +19706,42 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDescriptorPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDescriptorPoolCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorPoolCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, maxSets, poolSizeCount, pPoolSizes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorPoolCreateInfo const & ) const = default; #else bool operator==( DescriptorPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( maxSets == rhs.maxSets ) && - ( poolSizeCount == rhs.poolSizeCount ) && ( pPoolSizes == rhs.pPoolSizes ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -20683,28 +19767,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DescriptorPoolCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & descriptorPoolCreateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorPoolCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorPoolCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlags, seed, descriptorPoolCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorPoolCreateInfo.maxSets ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorPoolCreateInfo.poolSizeCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::DescriptorPoolSize *, seed, descriptorPoolCreateInfo.pPoolSizes ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DescriptorPoolInlineUniformBlockCreateInfoEXT { using NativeType = VkDescriptorPoolInlineUniformBlockCreateInfoEXT; @@ -20755,28 +19817,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxInlineUniformBlockBindings ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorPoolInlineUniformBlockCreateInfoEXT const & ) const = default; #else bool operator==( DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxInlineUniformBlockBindings == rhs.maxInlineUniformBlockBindings ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -20801,26 +19872,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DescriptorPoolInlineUniformBlockCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfoEXT const & - descriptorPoolInlineUniformBlockCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorPoolInlineUniformBlockCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorPoolInlineUniformBlockCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, descriptorPoolInlineUniformBlockCreateInfoEXT.maxInlineUniformBlockBindings ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DescriptorSetAllocateInfo { using NativeType = VkDescriptorSetAllocateInfo; @@ -20905,28 +19956,41 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDescriptorSetAllocateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorSetAllocateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDescriptorSetAllocateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorSetAllocateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, descriptorPool, descriptorSetCount, pSetLayouts ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetAllocateInfo const & ) const = default; #else bool operator==( DescriptorSetAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorPool == rhs.descriptorPool ) && - ( descriptorSetCount == rhs.descriptorSetCount ) && ( pSetLayouts == rhs.pSetLayouts ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorSetAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -20951,27 +20015,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DescriptorSetAllocateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & descriptorSetAllocateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetAllocateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorSetAllocateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorPool, seed, descriptorSetAllocateInfo.descriptorPool ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetAllocateInfo.descriptorSetCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::DescriptorSetLayout *, seed, descriptorSetAllocateInfo.pSetLayouts ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DescriptorSetLayoutBinding { using NativeType = VkDescriptorSetLayoutBinding; @@ -21067,29 +20110,41 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDescriptorSetLayoutBinding const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorSetLayoutBinding const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDescriptorSetLayoutBinding &() VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorSetLayoutBinding &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( binding, descriptorType, descriptorCount, stageFlags, pImmutableSamplers ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetLayoutBinding const & ) const = default; #else bool operator==( DescriptorSetLayoutBinding const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( binding == rhs.binding ) && ( descriptorType == rhs.descriptorType ) && - ( descriptorCount == rhs.descriptorCount ) && ( stageFlags == rhs.stageFlags ) && - ( pImmutableSamplers == rhs.pImmutableSamplers ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorSetLayoutBinding const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -21108,27 +20163,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "DescriptorSetLayoutBinding is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding const & descriptorSetLayoutBinding ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetLayoutBinding.binding ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, descriptorSetLayoutBinding.descriptorType ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetLayoutBinding.descriptorCount ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, descriptorSetLayoutBinding.stageFlags ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::Sampler *, seed, descriptorSetLayoutBinding.pImmutableSamplers ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DescriptorSetLayoutBindingFlagsCreateInfo { using NativeType = VkDescriptorSetLayoutBindingFlagsCreateInfo; @@ -21207,28 +20241,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDescriptorSetLayoutBindingFlagsCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorSetLayoutBindingFlagsCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDescriptorSetLayoutBindingFlagsCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorSetLayoutBindingFlagsCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, bindingCount, pBindingFlags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetLayoutBindingFlagsCreateInfo const & ) const = default; #else bool operator==( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bindingCount == rhs.bindingCount ) && - ( pBindingFlags == rhs.pBindingFlags ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -21255,28 +20301,6 @@ namespace VULKAN_HPP_NAMESPACE }; using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo const & - descriptorSetLayoutBindingFlagsCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetLayoutBindingFlagsCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorSetLayoutBindingFlagsCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetLayoutBindingFlagsCreateInfo.bindingCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::DescriptorBindingFlags *, - seed, - descriptorSetLayoutBindingFlagsCreateInfo.pBindingFlags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DescriptorSetLayoutCreateInfo { using NativeType = VkDescriptorSetLayoutCreateInfo; @@ -21360,28 +20384,41 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDescriptorSetLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorSetLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDescriptorSetLayoutCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorSetLayoutCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, bindingCount, pBindings ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetLayoutCreateInfo const & ) const = default; #else bool operator==( DescriptorSetLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( bindingCount == rhs.bindingCount ) && ( pBindings == rhs.pBindings ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorSetLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -21407,28 +20444,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DescriptorSetLayoutCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & descriptorSetLayoutCreateInfo ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetLayoutCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorSetLayoutCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlags, seed, descriptorSetLayoutCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetLayoutCreateInfo.bindingCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding *, seed, descriptorSetLayoutCreateInfo.pBindings ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DescriptorSetLayoutSupport { using NativeType = VkDescriptorSetLayoutSupport; @@ -21457,27 +20472,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkDescriptorSetLayoutSupport const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorSetLayoutSupport const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDescriptorSetLayoutSupport &() VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorSetLayoutSupport &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, supported ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetLayoutSupport const & ) const = default; #else bool operator==( DescriptorSetLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supported == rhs.supported ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorSetLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -21501,24 +20526,6 @@ namespace VULKAN_HPP_NAMESPACE }; using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport const & descriptorSetLayoutSupport ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetLayoutSupport.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, descriptorSetLayoutSupport.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, descriptorSetLayoutSupport.supported ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DescriptorSetVariableDescriptorCountAllocateInfo { using NativeType = VkDescriptorSetVariableDescriptorCountAllocateInfo; @@ -21596,28 +20603,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDescriptorSetVariableDescriptorCountAllocateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorSetVariableDescriptorCountAllocateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDescriptorSetVariableDescriptorCountAllocateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorSetVariableDescriptorCountAllocateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, descriptorSetCount, pDescriptorCounts ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetVariableDescriptorCountAllocateInfo const & ) const = default; #else bool operator==( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSetCount == rhs.descriptorSetCount ) && - ( pDescriptorCounts == rhs.pDescriptorCounts ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -21644,27 +20663,6 @@ namespace VULKAN_HPP_NAMESPACE }; using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo const & - descriptorSetVariableDescriptorCountAllocateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetVariableDescriptorCountAllocateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorSetVariableDescriptorCountAllocateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorSetVariableDescriptorCountAllocateInfo.descriptorSetCount ); - VULKAN_HPP_HASH_COMBINE( - const uint32_t *, seed, descriptorSetVariableDescriptorCountAllocateInfo.pDescriptorCounts ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DescriptorSetVariableDescriptorCountLayoutSupport { using NativeType = VkDescriptorSetVariableDescriptorCountLayoutSupport; @@ -21700,28 +20698,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkDescriptorSetVariableDescriptorCountLayoutSupport const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorSetVariableDescriptorCountLayoutSupport const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDescriptorSetVariableDescriptorCountLayoutSupport &() VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorSetVariableDescriptorCountLayoutSupport &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxVariableDescriptorCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetVariableDescriptorCountLayoutSupport const & ) const = default; #else bool operator==( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxVariableDescriptorCount == rhs.maxVariableDescriptorCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -21747,26 +20754,6 @@ namespace VULKAN_HPP_NAMESPACE }; using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport const & - descriptorSetVariableDescriptorCountLayoutSupport ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorSetVariableDescriptorCountLayoutSupport.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, descriptorSetVariableDescriptorCountLayoutSupport.pNext ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, descriptorSetVariableDescriptorCountLayoutSupport.maxVariableDescriptorCount ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DescriptorUpdateTemplateEntry { using NativeType = VkDescriptorUpdateTemplateEntry; @@ -21845,29 +20832,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDescriptorUpdateTemplateEntry const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorUpdateTemplateEntry const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDescriptorUpdateTemplateEntry &() VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorUpdateTemplateEntry &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( dstBinding, dstArrayElement, descriptorCount, descriptorType, offset, stride ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorUpdateTemplateEntry const & ) const = default; #else bool operator==( DescriptorUpdateTemplateEntry const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( dstBinding == rhs.dstBinding ) && ( dstArrayElement == rhs.dstArrayElement ) && - ( descriptorCount == rhs.descriptorCount ) && ( descriptorType == rhs.descriptorType ) && - ( offset == rhs.offset ) && ( stride == rhs.stride ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorUpdateTemplateEntry const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -21889,27 +20889,6 @@ namespace VULKAN_HPP_NAMESPACE "DescriptorUpdateTemplateEntry is not nothrow_move_constructible!" ); using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry const & descriptorUpdateTemplateEntry ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateEntry.dstBinding ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateEntry.dstArrayElement ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateEntry.descriptorCount ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, descriptorUpdateTemplateEntry.descriptorType ); - VULKAN_HPP_HASH_COMBINE( size_t, seed, descriptorUpdateTemplateEntry.offset ); - VULKAN_HPP_HASH_COMBINE( size_t, seed, descriptorUpdateTemplateEntry.stride ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DescriptorUpdateTemplateCreateInfo { using NativeType = VkDescriptorUpdateTemplateCreateInfo; @@ -22053,31 +21032,55 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDescriptorUpdateTemplateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorUpdateTemplateCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDescriptorUpdateTemplateCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkDescriptorUpdateTemplateCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + descriptorUpdateEntryCount, + pDescriptorUpdateEntries, + templateType, + descriptorSetLayout, + pipelineBindPoint, + pipelineLayout, + set ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorUpdateTemplateCreateInfo const & ) const = default; #else bool operator==( DescriptorUpdateTemplateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount ) && - ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries ) && ( templateType == rhs.templateType ) && - ( descriptorSetLayout == rhs.descriptorSetLayout ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && - ( pipelineLayout == rhs.pipelineLayout ) && ( set == rhs.set ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorUpdateTemplateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -22110,38 +21113,6 @@ namespace VULKAN_HPP_NAMESPACE }; using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & - descriptorUpdateTemplateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, descriptorUpdateTemplateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, descriptorUpdateTemplateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags, seed, descriptorUpdateTemplateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateCreateInfo.descriptorUpdateEntryCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry *, - seed, - descriptorUpdateTemplateCreateInfo.pDescriptorUpdateEntries ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType, seed, descriptorUpdateTemplateCreateInfo.templateType ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DescriptorSetLayout, seed, descriptorUpdateTemplateCreateInfo.descriptorSetLayout ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, descriptorUpdateTemplateCreateInfo.pipelineBindPoint ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineLayout, seed, descriptorUpdateTemplateCreateInfo.pipelineLayout ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, descriptorUpdateTemplateCreateInfo.set ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceBufferMemoryRequirementsKHR { using NativeType = VkDeviceBufferMemoryRequirementsKHR; @@ -22188,27 +21159,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDeviceBufferMemoryRequirementsKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceBufferMemoryRequirementsKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceBufferMemoryRequirementsKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceBufferMemoryRequirementsKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pCreateInfo ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceBufferMemoryRequirementsKHR const & ) const = default; #else bool operator==( DeviceBufferMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceBufferMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -22232,25 +21215,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DeviceBufferMemoryRequirementsKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR const & - deviceBufferMemoryRequirementsKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceBufferMemoryRequirementsKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceBufferMemoryRequirementsKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::BufferCreateInfo *, seed, deviceBufferMemoryRequirementsKHR.pCreateInfo ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceQueueCreateInfo { using NativeType = VkDeviceQueueCreateInfo; @@ -22340,29 +21304,42 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDeviceQueueCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceQueueCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceQueueCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceQueueCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, queueFamilyIndex, queueCount, pQueuePriorities ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceQueueCreateInfo const & ) const = default; #else bool operator==( DeviceQueueCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( queueFamilyIndex == rhs.queueFamilyIndex ) && ( queueCount == rhs.queueCount ) && - ( pQueuePriorities == rhs.pQueuePriorities ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceQueueCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -22387,27 +21364,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DeviceQueueCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo const & deviceQueueCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceQueueCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceQueueCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags, seed, deviceQueueCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceQueueCreateInfo.queueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceQueueCreateInfo.queueCount ); - VULKAN_HPP_HASH_COMBINE( const float *, seed, deviceQueueCreateInfo.pQueuePriorities ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceFeatures { using NativeType = VkPhysicalDeviceFeatures; @@ -22928,66 +21884,145 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceFeatures const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFeatures const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceFeatures &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFeatures &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( robustBufferAccess, + fullDrawIndexUint32, + imageCubeArray, + independentBlend, + geometryShader, + tessellationShader, + sampleRateShading, + dualSrcBlend, + logicOp, + multiDrawIndirect, + drawIndirectFirstInstance, + depthClamp, + depthBiasClamp, + fillModeNonSolid, + depthBounds, + wideLines, + largePoints, + alphaToOne, + multiViewport, + samplerAnisotropy, + textureCompressionETC2, + textureCompressionASTC_LDR, + textureCompressionBC, + occlusionQueryPrecise, + pipelineStatisticsQuery, + vertexPipelineStoresAndAtomics, + fragmentStoresAndAtomics, + shaderTessellationAndGeometryPointSize, + shaderImageGatherExtended, + shaderStorageImageExtendedFormats, + shaderStorageImageMultisample, + shaderStorageImageReadWithoutFormat, + shaderStorageImageWriteWithoutFormat, + shaderUniformBufferArrayDynamicIndexing, + shaderSampledImageArrayDynamicIndexing, + shaderStorageBufferArrayDynamicIndexing, + shaderStorageImageArrayDynamicIndexing, + shaderClipDistance, + shaderCullDistance, + shaderFloat64, + shaderInt64, + shaderInt16, + shaderResourceResidency, + shaderResourceMinLod, + sparseBinding, + sparseResidencyBuffer, + sparseResidencyImage2D, + sparseResidencyImage3D, + sparseResidency2Samples, + sparseResidency4Samples, + sparseResidency8Samples, + sparseResidency16Samples, + sparseResidencyAliased, + variableMultisampleRate, + inheritedQueries ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFeatures const & ) const = default; #else bool operator==( PhysicalDeviceFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( robustBufferAccess == rhs.robustBufferAccess ) && ( fullDrawIndexUint32 == rhs.fullDrawIndexUint32 ) && - ( imageCubeArray == rhs.imageCubeArray ) && ( independentBlend == rhs.independentBlend ) && - ( geometryShader == rhs.geometryShader ) && ( tessellationShader == rhs.tessellationShader ) && - ( sampleRateShading == rhs.sampleRateShading ) && ( dualSrcBlend == rhs.dualSrcBlend ) && - ( logicOp == rhs.logicOp ) && ( multiDrawIndirect == rhs.multiDrawIndirect ) && - ( drawIndirectFirstInstance == rhs.drawIndirectFirstInstance ) && ( depthClamp == rhs.depthClamp ) && - ( depthBiasClamp == rhs.depthBiasClamp ) && ( fillModeNonSolid == rhs.fillModeNonSolid ) && - ( depthBounds == rhs.depthBounds ) && ( wideLines == rhs.wideLines ) && - ( largePoints == rhs.largePoints ) && ( alphaToOne == rhs.alphaToOne ) && - ( multiViewport == rhs.multiViewport ) && ( samplerAnisotropy == rhs.samplerAnisotropy ) && - ( textureCompressionETC2 == rhs.textureCompressionETC2 ) && - ( textureCompressionASTC_LDR == rhs.textureCompressionASTC_LDR ) && - ( textureCompressionBC == rhs.textureCompressionBC ) && - ( occlusionQueryPrecise == rhs.occlusionQueryPrecise ) && - ( pipelineStatisticsQuery == rhs.pipelineStatisticsQuery ) && - ( vertexPipelineStoresAndAtomics == rhs.vertexPipelineStoresAndAtomics ) && - ( fragmentStoresAndAtomics == rhs.fragmentStoresAndAtomics ) && - ( shaderTessellationAndGeometryPointSize == rhs.shaderTessellationAndGeometryPointSize ) && - ( shaderImageGatherExtended == rhs.shaderImageGatherExtended ) && - ( shaderStorageImageExtendedFormats == rhs.shaderStorageImageExtendedFormats ) && - ( shaderStorageImageMultisample == rhs.shaderStorageImageMultisample ) && - ( shaderStorageImageReadWithoutFormat == rhs.shaderStorageImageReadWithoutFormat ) && - ( shaderStorageImageWriteWithoutFormat == rhs.shaderStorageImageWriteWithoutFormat ) && - ( shaderUniformBufferArrayDynamicIndexing == rhs.shaderUniformBufferArrayDynamicIndexing ) && - ( shaderSampledImageArrayDynamicIndexing == rhs.shaderSampledImageArrayDynamicIndexing ) && - ( shaderStorageBufferArrayDynamicIndexing == rhs.shaderStorageBufferArrayDynamicIndexing ) && - ( shaderStorageImageArrayDynamicIndexing == rhs.shaderStorageImageArrayDynamicIndexing ) && - ( shaderClipDistance == rhs.shaderClipDistance ) && ( shaderCullDistance == rhs.shaderCullDistance ) && - ( shaderFloat64 == rhs.shaderFloat64 ) && ( shaderInt64 == rhs.shaderInt64 ) && - ( shaderInt16 == rhs.shaderInt16 ) && ( shaderResourceResidency == rhs.shaderResourceResidency ) && - ( shaderResourceMinLod == rhs.shaderResourceMinLod ) && ( sparseBinding == rhs.sparseBinding ) && - ( sparseResidencyBuffer == rhs.sparseResidencyBuffer ) && - ( sparseResidencyImage2D == rhs.sparseResidencyImage2D ) && - ( sparseResidencyImage3D == rhs.sparseResidencyImage3D ) && - ( sparseResidency2Samples == rhs.sparseResidency2Samples ) && - ( sparseResidency4Samples == rhs.sparseResidency4Samples ) && - ( sparseResidency8Samples == rhs.sparseResidency8Samples ) && - ( sparseResidency16Samples == rhs.sparseResidency16Samples ) && - ( sparseResidencyAliased == rhs.sparseResidencyAliased ) && - ( variableMultisampleRate == rhs.variableMultisampleRate ) && ( inheritedQueries == rhs.inheritedQueries ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -23056,85 +22091,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "PhysicalDeviceFeatures is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const & physicalDeviceFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.robustBufferAccess ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.fullDrawIndexUint32 ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.imageCubeArray ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.independentBlend ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.geometryShader ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.tessellationShader ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sampleRateShading ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.dualSrcBlend ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.logicOp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.multiDrawIndirect ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.drawIndirectFirstInstance ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.depthClamp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.depthBiasClamp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.fillModeNonSolid ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.depthBounds ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.wideLines ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.largePoints ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.alphaToOne ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.multiViewport ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.samplerAnisotropy ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.textureCompressionETC2 ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.textureCompressionASTC_LDR ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.textureCompressionBC ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.occlusionQueryPrecise ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.pipelineStatisticsQuery ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.vertexPipelineStoresAndAtomics ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.fragmentStoresAndAtomics ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderTessellationAndGeometryPointSize ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderImageGatherExtended ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageExtendedFormats ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageMultisample ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageReadWithoutFormat ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderClipDistance ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderCullDistance ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderFloat64 ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderInt64 ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderInt16 ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderResourceResidency ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.shaderResourceMinLod ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseBinding ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidencyBuffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidencyImage2D ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidencyImage3D ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidency2Samples ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidency4Samples ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidency8Samples ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidency16Samples ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.sparseResidencyAliased ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.variableMultisampleRate ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFeatures.inheritedQueries ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceCreateInfo { using NativeType = VkDeviceCreateInfo; @@ -23291,31 +22247,55 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDeviceCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + queueCreateInfoCount, + pQueueCreateInfos, + enabledLayerCount, + ppEnabledLayerNames, + enabledExtensionCount, + ppEnabledExtensionNames, + pEnabledFeatures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceCreateInfo const & ) const = default; #else bool operator==( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( queueCreateInfoCount == rhs.queueCreateInfoCount ) && ( pQueueCreateInfos == rhs.pQueueCreateInfos ) && - ( enabledLayerCount == rhs.enabledLayerCount ) && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames ) && - ( enabledExtensionCount == rhs.enabledExtensionCount ) && - ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames ) && ( pEnabledFeatures == rhs.pEnabledFeatures ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -23344,32 +22324,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DeviceCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & deviceCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceCreateFlags, seed, deviceCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceCreateInfo.queueCreateInfoCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo *, seed, deviceCreateInfo.pQueueCreateInfos ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceCreateInfo.enabledLayerCount ); - VULKAN_HPP_HASH_COMBINE( const char * const *, seed, deviceCreateInfo.ppEnabledLayerNames ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceCreateInfo.enabledExtensionCount ); - VULKAN_HPP_HASH_COMBINE( const char * const *, seed, deviceCreateInfo.ppEnabledExtensionNames ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures *, seed, deviceCreateInfo.pEnabledFeatures ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceDeviceMemoryReportCreateInfoEXT { using NativeType = VkDeviceDeviceMemoryReportCreateInfoEXT; @@ -23436,28 +22390,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDeviceDeviceMemoryReportCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceDeviceMemoryReportCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceDeviceMemoryReportCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceDeviceMemoryReportCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pfnUserCallback, pUserData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceDeviceMemoryReportCreateInfoEXT const & ) const = default; #else bool operator==( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( pfnUserCallback == rhs.pfnUserCallback ) && ( pUserData == rhs.pUserData ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -23483,28 +22450,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DeviceDeviceMemoryReportCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT const & - deviceDeviceMemoryReportCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceDeviceMemoryReportCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceDeviceMemoryReportCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT, seed, deviceDeviceMemoryReportCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( - PFN_vkDeviceMemoryReportCallbackEXT, seed, deviceDeviceMemoryReportCreateInfoEXT.pfnUserCallback ); - VULKAN_HPP_HASH_COMBINE( void *, seed, deviceDeviceMemoryReportCreateInfoEXT.pUserData ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceDiagnosticsConfigCreateInfoNV { using NativeType = VkDeviceDiagnosticsConfigCreateInfoNV; @@ -23551,27 +22496,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDeviceDiagnosticsConfigCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceDiagnosticsConfigCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceDiagnosticsConfigCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceDiagnosticsConfigCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceDiagnosticsConfigCreateInfoNV const & ) const = default; #else bool operator==( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -23595,25 +22552,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DeviceDiagnosticsConfigCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV const & - deviceDiagnosticsConfigCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceDiagnosticsConfigCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceDiagnosticsConfigCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV, seed, deviceDiagnosticsConfigCreateInfoNV.flags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceEventInfoEXT { using NativeType = VkDeviceEventInfoEXT; @@ -23658,27 +22596,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDeviceEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceEventInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceEventInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceEvent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceEventInfoEXT const & ) const = default; #else bool operator==( DeviceEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceEvent == rhs.deviceEvent ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -23700,24 +22650,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DeviceEventInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceEventInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceEventInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT, seed, deviceEventInfoEXT.deviceEvent ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceGroupBindSparseInfo { using NativeType = VkDeviceGroupBindSparseInfo; @@ -23770,28 +22702,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDeviceGroupBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceGroupBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceGroupBindSparseInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceGroupBindSparseInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, resourceDeviceIndex, memoryDeviceIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupBindSparseInfo const & ) const = default; #else bool operator==( DeviceGroupBindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( resourceDeviceIndex == rhs.resourceDeviceIndex ) && - ( memoryDeviceIndex == rhs.memoryDeviceIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceGroupBindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -23816,25 +22757,6 @@ namespace VULKAN_HPP_NAMESPACE }; using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo const & deviceGroupBindSparseInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupBindSparseInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupBindSparseInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupBindSparseInfo.resourceDeviceIndex ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupBindSparseInfo.memoryDeviceIndex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceGroupCommandBufferBeginInfo { using NativeType = VkDeviceGroupCommandBufferBeginInfo; @@ -23880,27 +22802,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDeviceGroupCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceGroupCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceGroupCommandBufferBeginInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceGroupCommandBufferBeginInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupCommandBufferBeginInfo const & ) const = default; #else bool operator==( DeviceGroupCommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMask == rhs.deviceMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceGroupCommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -23925,24 +22857,6 @@ namespace VULKAN_HPP_NAMESPACE }; using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo const & - deviceGroupCommandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupCommandBufferBeginInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupCommandBufferBeginInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupCommandBufferBeginInfo.deviceMask ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceGroupDeviceCreateInfo { using NativeType = VkDeviceGroupDeviceCreateInfo; @@ -24016,28 +22930,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDeviceGroupDeviceCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceGroupDeviceCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceGroupDeviceCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceGroupDeviceCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, physicalDeviceCount, pPhysicalDevices ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupDeviceCreateInfo const & ) const = default; #else bool operator==( DeviceGroupDeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) && - ( pPhysicalDevices == rhs.pPhysicalDevices ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceGroupDeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -24063,26 +22989,6 @@ namespace VULKAN_HPP_NAMESPACE }; using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo const & deviceGroupDeviceCreateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupDeviceCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupDeviceCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupDeviceCreateInfo.physicalDeviceCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::PhysicalDevice *, seed, deviceGroupDeviceCreateInfo.pPhysicalDevices ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceGroupPresentCapabilitiesKHR { using NativeType = VkDeviceGroupPresentCapabilitiesKHR; @@ -24116,28 +23022,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkDeviceGroupPresentCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceGroupPresentCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceGroupPresentCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceGroupPresentCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentMask, modes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupPresentCapabilitiesKHR const & ) const = default; #else bool operator==( DeviceGroupPresentCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentMask == rhs.presentMask ) && - ( modes == rhs.modes ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceGroupPresentCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -24162,29 +23080,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DeviceGroupPresentCapabilitiesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR const & - deviceGroupPresentCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupPresentCapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, deviceGroupPresentCapabilitiesKHR.pNext ); - for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupPresentCapabilitiesKHR.presentMask[i] ); - } - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR, seed, deviceGroupPresentCapabilitiesKHR.modes ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceGroupPresentInfoKHR { using NativeType = VkDeviceGroupPresentInfoKHR; @@ -24268,28 +23163,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDeviceGroupPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceGroupPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceGroupPresentInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceGroupPresentInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchainCount, pDeviceMasks, mode ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupPresentInfoKHR const & ) const = default; #else bool operator==( DeviceGroupPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && - ( pDeviceMasks == rhs.pDeviceMasks ) && ( mode == rhs.mode ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceGroupPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -24315,27 +23223,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DeviceGroupPresentInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR const & deviceGroupPresentInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupPresentInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupPresentInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupPresentInfoKHR.swapchainCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, deviceGroupPresentInfoKHR.pDeviceMasks ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR, seed, deviceGroupPresentInfoKHR.mode ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceGroupRenderPassBeginInfo { using NativeType = VkDeviceGroupRenderPassBeginInfo; @@ -24419,28 +23306,41 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDeviceGroupRenderPassBeginInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceGroupRenderPassBeginInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceGroupRenderPassBeginInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceGroupRenderPassBeginInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceMask, deviceRenderAreaCount, pDeviceRenderAreas ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupRenderPassBeginInfo const & ) const = default; #else bool operator==( DeviceGroupRenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMask == rhs.deviceMask ) && - ( deviceRenderAreaCount == rhs.deviceRenderAreaCount ) && ( pDeviceRenderAreas == rhs.pDeviceRenderAreas ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceGroupRenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -24467,27 +23367,6 @@ namespace VULKAN_HPP_NAMESPACE }; using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo const & deviceGroupRenderPassBeginInfo ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupRenderPassBeginInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupRenderPassBeginInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupRenderPassBeginInfo.deviceMask ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupRenderPassBeginInfo.deviceRenderAreaCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::Rect2D *, seed, deviceGroupRenderPassBeginInfo.pDeviceRenderAreas ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceGroupSubmitInfo { using NativeType = VkDeviceGroupSubmitInfo; @@ -24623,32 +23502,51 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDeviceGroupSubmitInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceGroupSubmitInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceGroupSubmitInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceGroupSubmitInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + waitSemaphoreCount, + pWaitSemaphoreDeviceIndices, + commandBufferCount, + pCommandBufferDeviceMasks, + signalSemaphoreCount, + pSignalSemaphoreDeviceIndices ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupSubmitInfo const & ) const = default; #else bool operator==( DeviceGroupSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) && - ( pWaitSemaphoreDeviceIndices == rhs.pWaitSemaphoreDeviceIndices ) && - ( commandBufferCount == rhs.commandBufferCount ) && - ( pCommandBufferDeviceMasks == rhs.pCommandBufferDeviceMasks ) && - ( signalSemaphoreCount == rhs.signalSemaphoreCount ) && - ( pSignalSemaphoreDeviceIndices == rhs.pSignalSemaphoreDeviceIndices ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceGroupSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -24676,29 +23574,6 @@ namespace VULKAN_HPP_NAMESPACE }; using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo const & deviceGroupSubmitInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupSubmitInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupSubmitInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupSubmitInfo.waitSemaphoreCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, deviceGroupSubmitInfo.pWaitSemaphoreDeviceIndices ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupSubmitInfo.commandBufferCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, deviceGroupSubmitInfo.pCommandBufferDeviceMasks ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceGroupSubmitInfo.signalSemaphoreCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, deviceGroupSubmitInfo.pSignalSemaphoreDeviceIndices ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceGroupSwapchainCreateInfoKHR { using NativeType = VkDeviceGroupSwapchainCreateInfoKHR; @@ -24744,27 +23619,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDeviceGroupSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceGroupSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceGroupSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceGroupSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, modes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupSwapchainCreateInfoKHR const & ) const = default; #else bool operator==( DeviceGroupSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( modes == rhs.modes ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceGroupSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -24788,25 +23675,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DeviceGroupSwapchainCreateInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR const & - deviceGroupSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceGroupSwapchainCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceGroupSwapchainCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR, seed, deviceGroupSwapchainCreateInfoKHR.modes ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageCreateInfo { using NativeType = VkImageCreateInfo; @@ -24994,32 +23862,65 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + imageType, + format, + extent, + mipLevels, + arrayLayers, + samples, + tiling, + usage, + sharingMode, + queueFamilyIndexCount, + pQueueFamilyIndices, + initialLayout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageCreateInfo const & ) const = default; #else bool operator==( ImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( imageType == rhs.imageType ) && ( format == rhs.format ) && ( extent == rhs.extent ) && - ( mipLevels == rhs.mipLevels ) && ( arrayLayers == rhs.arrayLayers ) && ( samples == rhs.samples ) && - ( tiling == rhs.tiling ) && ( usage == rhs.usage ) && ( sharingMode == rhs.sharingMode ) && - ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && - ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) && ( initialLayout == rhs.initialLayout ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -25053,35 +23954,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImageCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & imageCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageCreateFlags, seed, imageCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageType, seed, imageCreateInfo.imageType ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, imageCreateInfo.format ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageCreateInfo.extent ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageCreateInfo.mipLevels ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageCreateInfo.arrayLayers ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, imageCreateInfo.samples ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageTiling, seed, imageCreateInfo.tiling ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, imageCreateInfo.usage ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SharingMode, seed, imageCreateInfo.sharingMode ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageCreateInfo.queueFamilyIndexCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, imageCreateInfo.pQueueFamilyIndices ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageCreateInfo.initialLayout ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceImageMemoryRequirementsKHR { using NativeType = VkDeviceImageMemoryRequirementsKHR; @@ -25137,28 +24009,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDeviceImageMemoryRequirementsKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceImageMemoryRequirementsKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceImageMemoryRequirementsKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceImageMemoryRequirementsKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pCreateInfo, planeAspect ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceImageMemoryRequirementsKHR const & ) const = default; #else bool operator==( DeviceImageMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ) && - ( planeAspect == rhs.planeAspect ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceImageMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -25183,28 +24067,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DeviceImageMemoryRequirementsKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR const & deviceImageMemoryRequirementsKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceImageMemoryRequirementsKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceImageMemoryRequirementsKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::ImageCreateInfo *, seed, deviceImageMemoryRequirementsKHR.pCreateInfo ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ImageAspectFlagBits, seed, deviceImageMemoryRequirementsKHR.planeAspect ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceMemoryOpaqueCaptureAddressInfo { using NativeType = VkDeviceMemoryOpaqueCaptureAddressInfo; @@ -25252,27 +24114,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDeviceMemoryOpaqueCaptureAddressInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceMemoryOpaqueCaptureAddressInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceMemoryOpaqueCaptureAddressInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceMemoryOpaqueCaptureAddressInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceMemoryOpaqueCaptureAddressInfo const & ) const = default; #else bool operator==( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -25297,24 +24171,6 @@ namespace VULKAN_HPP_NAMESPACE }; using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo const & - deviceMemoryOpaqueCaptureAddressInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceMemoryOpaqueCaptureAddressInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceMemoryOpaqueCaptureAddressInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, deviceMemoryOpaqueCaptureAddressInfo.memory ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceMemoryOverallocationCreateInfoAMD { using NativeType = VkDeviceMemoryOverallocationCreateInfoAMD; @@ -25365,28 +24221,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDeviceMemoryOverallocationCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceMemoryOverallocationCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceMemoryOverallocationCreateInfoAMD &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceMemoryOverallocationCreateInfoAMD &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, overallocationBehavior ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceMemoryOverallocationCreateInfoAMD const & ) const = default; #else bool operator==( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( overallocationBehavior == rhs.overallocationBehavior ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -25412,26 +24279,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DeviceMemoryOverallocationCreateInfoAMD; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD const & - deviceMemoryOverallocationCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceMemoryOverallocationCreateInfoAMD.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceMemoryOverallocationCreateInfoAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD, - seed, - deviceMemoryOverallocationCreateInfoAMD.overallocationBehavior ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceMemoryReportCallbackDataEXT { using NativeType = VkDeviceMemoryReportCallbackDataEXT; @@ -25476,29 +24323,45 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkDeviceMemoryReportCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceMemoryReportCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceMemoryReportCallbackDataEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceMemoryReportCallbackDataEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, type, memoryObjectId, size, objectType, objectHandle, heapIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceMemoryReportCallbackDataEXT const & ) const = default; #else bool operator==( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( type == rhs.type ) && - ( memoryObjectId == rhs.memoryObjectId ) && ( size == rhs.size ) && ( objectType == rhs.objectType ) && - ( objectHandle == rhs.objectHandle ) && ( heapIndex == rhs.heapIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -25529,32 +24392,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DeviceMemoryReportCallbackDataEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT const & - deviceMemoryReportCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceMemoryReportCallbackDataEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, deviceMemoryReportCallbackDataEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT, seed, deviceMemoryReportCallbackDataEXT.flags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT, seed, deviceMemoryReportCallbackDataEXT.type ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, deviceMemoryReportCallbackDataEXT.memoryObjectId ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, deviceMemoryReportCallbackDataEXT.size ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ObjectType, seed, deviceMemoryReportCallbackDataEXT.objectType ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, deviceMemoryReportCallbackDataEXT.objectHandle ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceMemoryReportCallbackDataEXT.heapIndex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DevicePrivateDataCreateInfoEXT { using NativeType = VkDevicePrivateDataCreateInfoEXT; @@ -25600,28 +24437,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDevicePrivateDataCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDevicePrivateDataCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDevicePrivateDataCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDevicePrivateDataCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, privateDataSlotRequestCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DevicePrivateDataCreateInfoEXT const & ) const = default; #else bool operator==( DevicePrivateDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( privateDataSlotRequestCount == rhs.privateDataSlotRequestCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( DevicePrivateDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -25645,24 +24491,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DevicePrivateDataCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfoEXT const & devicePrivateDataCreateInfoEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, devicePrivateDataCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, devicePrivateDataCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, devicePrivateDataCreateInfoEXT.privateDataSlotRequestCount ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceQueueGlobalPriorityCreateInfoEXT { using NativeType = VkDeviceQueueGlobalPriorityCreateInfoEXT; @@ -25712,27 +24540,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDeviceQueueGlobalPriorityCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceQueueGlobalPriorityCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceQueueGlobalPriorityCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceQueueGlobalPriorityCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, globalPriority ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceQueueGlobalPriorityCreateInfoEXT const & ) const = default; #else bool operator==( DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriority == rhs.globalPriority ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -25757,25 +24597,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DeviceQueueGlobalPriorityCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoEXT const & - deviceQueueGlobalPriorityCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceQueueGlobalPriorityCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceQueueGlobalPriorityCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT, seed, deviceQueueGlobalPriorityCreateInfoEXT.globalPriority ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DeviceQueueInfo2 { using NativeType = VkDeviceQueueInfo2; @@ -25834,28 +24655,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDeviceQueueInfo2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceQueueInfo2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDeviceQueueInfo2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkDeviceQueueInfo2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, queueFamilyIndex, queueIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceQueueInfo2 const & ) const = default; #else bool operator==( DeviceQueueInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( queueFamilyIndex == rhs.queueFamilyIndex ) && ( queueIndex == rhs.queueIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceQueueInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -25879,25 +24713,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DeviceQueueInfo2; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & deviceQueueInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, deviceQueueInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, deviceQueueInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags, seed, deviceQueueInfo2.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceQueueInfo2.queueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, deviceQueueInfo2.queueIndex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) struct DirectFBSurfaceCreateInfoEXT { @@ -25958,28 +24773,41 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDirectFBSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDirectFBSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDirectFBSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDirectFBSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, dfb, surface ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DirectFBSurfaceCreateInfoEXT const & ) const = default; # else bool operator==( DirectFBSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dfb == rhs.dfb ) && - ( surface == rhs.surface ); + return this->reflect() == rhs.reflect(); } bool operator!=( DirectFBSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -26004,28 +24832,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = DirectFBSurfaceCreateInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( - VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & directFBSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, directFBSurfaceCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, directFBSurfaceCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateFlagsEXT, seed, directFBSurfaceCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( IDirectFB *, seed, directFBSurfaceCreateInfoEXT.dfb ); - VULKAN_HPP_HASH_COMBINE( IDirectFBSurface *, seed, directFBSurfaceCreateInfoEXT.surface ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ struct DispatchIndirectCommand @@ -26075,27 +24881,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDispatchIndirectCommand const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDispatchIndirectCommand const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDispatchIndirectCommand &() VULKAN_HPP_NOEXCEPT + explicit operator VkDispatchIndirectCommand &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y, z ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DispatchIndirectCommand const & ) const = default; #else bool operator==( DispatchIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z ); + return this->reflect() == rhs.reflect(); } bool operator!=( DispatchIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -26112,24 +24928,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "DispatchIndirectCommand is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchIndirectCommand const & dispatchIndirectCommand ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dispatchIndirectCommand.x ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dispatchIndirectCommand.y ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, dispatchIndirectCommand.z ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DisplayEventInfoEXT { using NativeType = VkDisplayEventInfoEXT; @@ -26174,27 +24972,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDisplayEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDisplayEventInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayEventInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, displayEvent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayEventInfoEXT const & ) const = default; #else bool operator==( DisplayEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayEvent == rhs.displayEvent ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -26216,24 +25026,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DisplayEventInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayEventInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, displayEventInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT, seed, displayEventInfoEXT.displayEvent ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DisplayModeParametersKHR { using NativeType = VkDisplayModeParametersKHR; @@ -26275,27 +25067,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDisplayModeParametersKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayModeParametersKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDisplayModeParametersKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayModeParametersKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( visibleRegion, refreshRate ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayModeParametersKHR const & ) const = default; #else bool operator==( DisplayModeParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( visibleRegion == rhs.visibleRegion ) && ( refreshRate == rhs.refreshRate ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayModeParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -26311,23 +25113,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "DisplayModeParametersKHR is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const & displayModeParametersKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayModeParametersKHR.visibleRegion ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displayModeParametersKHR.refreshRate ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DisplayModeCreateInfoKHR { using NativeType = VkDisplayModeCreateInfoKHR; @@ -26380,28 +25165,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDisplayModeCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayModeCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDisplayModeCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayModeCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, parameters ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayModeCreateInfoKHR const & ) const = default; #else bool operator==( DisplayModeCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( parameters == rhs.parameters ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayModeCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -26425,26 +25222,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DisplayModeCreateInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & displayModeCreateInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayModeCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, displayModeCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagsKHR, seed, displayModeCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR, seed, displayModeCreateInfoKHR.parameters ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DisplayModePropertiesKHR { using NativeType = VkDisplayModePropertiesKHR; @@ -26472,27 +25249,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkDisplayModePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayModePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDisplayModePropertiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayModePropertiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( displayMode, parameters ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayModePropertiesKHR const & ) const = default; #else bool operator==( DisplayModePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( displayMode == rhs.displayMode ) && ( parameters == rhs.parameters ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayModePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -26508,24 +25295,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "DisplayModePropertiesKHR is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR const & displayModePropertiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayModeKHR, seed, displayModePropertiesKHR.displayMode ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR, seed, displayModePropertiesKHR.parameters ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DisplayModeProperties2KHR { using NativeType = VkDisplayModeProperties2KHR; @@ -26555,27 +25324,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkDisplayModeProperties2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayModeProperties2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDisplayModeProperties2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayModeProperties2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, displayModeProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayModeProperties2KHR const & ) const = default; #else bool operator==( DisplayModeProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayModeProperties == rhs.displayModeProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayModeProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -26598,25 +25379,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DisplayModeProperties2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR const & displayModeProperties2KHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayModeProperties2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, displayModeProperties2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, seed, displayModeProperties2KHR.displayModeProperties ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DisplayNativeHdrSurfaceCapabilitiesAMD { using NativeType = VkDisplayNativeHdrSurfaceCapabilitiesAMD; @@ -26650,27 +25412,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkDisplayNativeHdrSurfaceCapabilitiesAMD const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayNativeHdrSurfaceCapabilitiesAMD const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDisplayNativeHdrSurfaceCapabilitiesAMD &() VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayNativeHdrSurfaceCapabilitiesAMD &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, localDimmingSupport ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayNativeHdrSurfaceCapabilitiesAMD const & ) const = default; #else bool operator==( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( localDimmingSupport == rhs.localDimmingSupport ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -26695,25 +25467,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DisplayNativeHdrSurfaceCapabilitiesAMD; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD const & - displayNativeHdrSurfaceCapabilitiesAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayNativeHdrSurfaceCapabilitiesAMD.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, displayNativeHdrSurfaceCapabilitiesAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, displayNativeHdrSurfaceCapabilitiesAMD.localDimmingSupport ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DisplayPlaneCapabilitiesKHR { using NativeType = VkDisplayPlaneCapabilitiesKHR; @@ -26756,31 +25509,53 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkDisplayPlaneCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayPlaneCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDisplayPlaneCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayPlaneCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( supportedAlpha, + minSrcPosition, + maxSrcPosition, + minSrcExtent, + maxSrcExtent, + minDstPosition, + maxDstPosition, + minDstExtent, + maxDstExtent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPlaneCapabilitiesKHR const & ) const = default; #else bool operator==( DisplayPlaneCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( supportedAlpha == rhs.supportedAlpha ) && ( minSrcPosition == rhs.minSrcPosition ) && - ( maxSrcPosition == rhs.maxSrcPosition ) && ( minSrcExtent == rhs.minSrcExtent ) && - ( maxSrcExtent == rhs.maxSrcExtent ) && ( minDstPosition == rhs.minDstPosition ) && - ( maxDstPosition == rhs.maxDstPosition ) && ( minDstExtent == rhs.minDstExtent ) && - ( maxDstExtent == rhs.maxDstExtent ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayPlaneCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -26804,31 +25579,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "DisplayPlaneCapabilitiesKHR is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR const & displayPlaneCapabilitiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagsKHR, seed, displayPlaneCapabilitiesKHR.supportedAlpha ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, displayPlaneCapabilitiesKHR.minSrcPosition ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, displayPlaneCapabilitiesKHR.maxSrcPosition ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPlaneCapabilitiesKHR.minSrcExtent ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPlaneCapabilitiesKHR.maxSrcExtent ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, displayPlaneCapabilitiesKHR.minDstPosition ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, displayPlaneCapabilitiesKHR.maxDstPosition ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPlaneCapabilitiesKHR.minDstExtent ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPlaneCapabilitiesKHR.maxDstExtent ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DisplayPlaneCapabilities2KHR { using NativeType = VkDisplayPlaneCapabilities2KHR; @@ -26858,27 +25608,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkDisplayPlaneCapabilities2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayPlaneCapabilities2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDisplayPlaneCapabilities2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayPlaneCapabilities2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, capabilities ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPlaneCapabilities2KHR const & ) const = default; #else bool operator==( DisplayPlaneCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( capabilities == rhs.capabilities ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayPlaneCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -26902,25 +25664,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DisplayPlaneCapabilities2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( - VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR const & displayPlaneCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPlaneCapabilities2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, displayPlaneCapabilities2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR, seed, displayPlaneCapabilities2KHR.capabilities ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DisplayPlaneInfo2KHR { using NativeType = VkDisplayPlaneInfo2KHR; @@ -26971,28 +25714,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDisplayPlaneInfo2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayPlaneInfo2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDisplayPlaneInfo2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayPlaneInfo2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, mode, planeIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPlaneInfo2KHR const & ) const = default; #else bool operator==( DisplayPlaneInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mode == rhs.mode ) && - ( planeIndex == rhs.planeIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayPlaneInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -27015,25 +25770,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DisplayPlaneInfo2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR const & displayPlaneInfo2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPlaneInfo2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, displayPlaneInfo2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayModeKHR, seed, displayPlaneInfo2KHR.mode ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displayPlaneInfo2KHR.planeIndex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DisplayPlanePropertiesKHR { using NativeType = VkDisplayPlanePropertiesKHR; @@ -27061,27 +25797,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkDisplayPlanePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayPlanePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDisplayPlanePropertiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayPlanePropertiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( currentDisplay, currentStackIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPlanePropertiesKHR const & ) const = default; #else bool operator==( DisplayPlanePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( currentDisplay == rhs.currentDisplay ) && ( currentStackIndex == rhs.currentStackIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayPlanePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -27097,23 +25843,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "DisplayPlanePropertiesKHR is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR const & displayPlanePropertiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayKHR, seed, displayPlanePropertiesKHR.currentDisplay ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displayPlanePropertiesKHR.currentStackIndex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DisplayPlaneProperties2KHR { using NativeType = VkDisplayPlaneProperties2KHR; @@ -27143,28 +25872,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkDisplayPlaneProperties2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayPlaneProperties2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDisplayPlaneProperties2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayPlaneProperties2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, displayPlaneProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPlaneProperties2KHR const & ) const = default; #else bool operator==( DisplayPlaneProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( displayPlaneProperties == rhs.displayPlaneProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayPlaneProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -27187,25 +25927,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DisplayPlaneProperties2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR const & displayPlaneProperties2KHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPlaneProperties2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, displayPlaneProperties2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, seed, displayPlaneProperties2KHR.displayPlaneProperties ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DisplayPowerInfoEXT { using NativeType = VkDisplayPowerInfoEXT; @@ -27249,27 +25970,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDisplayPowerInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayPowerInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDisplayPowerInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayPowerInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, powerState ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPowerInfoEXT const & ) const = default; #else bool operator==( DisplayPowerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( powerState == rhs.powerState ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayPowerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -27291,24 +26024,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DisplayPowerInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT const & displayPowerInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPowerInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, displayPowerInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT, seed, displayPowerInfoEXT.powerState ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DisplayPresentInfoKHR { using NativeType = VkDisplayPresentInfoKHR; @@ -27369,28 +26084,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDisplayPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDisplayPresentInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayPresentInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcRect, dstRect, persistent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPresentInfoKHR const & ) const = default; #else bool operator==( DisplayPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcRect == rhs.srcRect ) && - ( dstRect == rhs.dstRect ) && ( persistent == rhs.persistent ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -27414,26 +26142,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DisplayPresentInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR const & displayPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayPresentInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, displayPresentInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, displayPresentInfoKHR.srcRect ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, displayPresentInfoKHR.dstRect ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, displayPresentInfoKHR.persistent ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DisplayPropertiesKHR { using NativeType = VkDisplayPropertiesKHR; @@ -27471,30 +26179,49 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkDisplayPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDisplayPropertiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayPropertiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( display, + displayName, + physicalDimensions, + physicalResolution, + supportedTransforms, + planeReorderPossible, + persistentContent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPropertiesKHR const & ) const = default; #else bool operator==( DisplayPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( display == rhs.display ) && ( displayName == rhs.displayName ) && - ( physicalDimensions == rhs.physicalDimensions ) && ( physicalResolution == rhs.physicalResolution ) && - ( supportedTransforms == rhs.supportedTransforms ) && - ( planeReorderPossible == rhs.planeReorderPossible ) && ( persistentContent == rhs.persistentContent ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -27514,29 +26241,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "DisplayPropertiesKHR is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR const & displayPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayKHR, seed, displayPropertiesKHR.display ); - VULKAN_HPP_HASH_COMBINE( const char *, seed, displayPropertiesKHR.displayName ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPropertiesKHR.physicalDimensions ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displayPropertiesKHR.physicalResolution ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR, seed, displayPropertiesKHR.supportedTransforms ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, displayPropertiesKHR.planeReorderPossible ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, displayPropertiesKHR.persistentContent ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DisplayProperties2KHR { using NativeType = VkDisplayProperties2KHR; @@ -27565,27 +26269,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkDisplayProperties2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayProperties2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDisplayProperties2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDisplayProperties2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, displayProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayProperties2KHR const & ) const = default; #else bool operator==( DisplayProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayProperties == rhs.displayProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -27607,25 +26323,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DisplayProperties2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DisplayProperties2KHR const & displayProperties2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displayProperties2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, displayProperties2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, seed, displayProperties2KHR.displayProperties ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DisplaySurfaceCreateInfoKHR { using NativeType = VkDisplaySurfaceCreateInfoKHR; @@ -27733,30 +26430,47 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDisplaySurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDisplaySurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDisplaySurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkDisplaySurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, flags, displayMode, planeIndex, planeStackIndex, transform, globalAlpha, alphaMode, imageExtent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplaySurfaceCreateInfoKHR const & ) const = default; #else bool operator==( DisplaySurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( displayMode == rhs.displayMode ) && ( planeIndex == rhs.planeIndex ) && - ( planeStackIndex == rhs.planeStackIndex ) && ( transform == rhs.transform ) && - ( globalAlpha == rhs.globalAlpha ) && ( alphaMode == rhs.alphaMode ) && ( imageExtent == rhs.imageExtent ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplaySurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -27789,34 +26503,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DisplaySurfaceCreateInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & displaySurfaceCreateInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, displaySurfaceCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, displaySurfaceCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagsKHR, seed, displaySurfaceCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DisplayModeKHR, seed, displaySurfaceCreateInfoKHR.displayMode ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displaySurfaceCreateInfoKHR.planeIndex ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, displaySurfaceCreateInfoKHR.planeStackIndex ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, displaySurfaceCreateInfoKHR.transform ); - VULKAN_HPP_HASH_COMBINE( float, seed, displaySurfaceCreateInfoKHR.globalAlpha ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR, seed, displaySurfaceCreateInfoKHR.alphaMode ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, displaySurfaceCreateInfoKHR.imageExtent ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DrawIndexedIndirectCommand { using NativeType = VkDrawIndexedIndirectCommand; @@ -27882,29 +26568,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDrawIndexedIndirectCommand const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDrawIndexedIndirectCommand const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDrawIndexedIndirectCommand &() VULKAN_HPP_NOEXCEPT + explicit operator VkDrawIndexedIndirectCommand &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrawIndexedIndirectCommand const & ) const = default; #else bool operator==( DrawIndexedIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( indexCount == rhs.indexCount ) && ( instanceCount == rhs.instanceCount ) && - ( firstIndex == rhs.firstIndex ) && ( vertexOffset == rhs.vertexOffset ) && - ( firstInstance == rhs.firstInstance ); + return this->reflect() == rhs.reflect(); } bool operator!=( DrawIndexedIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -27923,26 +26617,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "DrawIndexedIndirectCommand is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand const & drawIndexedIndirectCommand ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndexedIndirectCommand.indexCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndexedIndirectCommand.instanceCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndexedIndirectCommand.firstIndex ); - VULKAN_HPP_HASH_COMBINE( int32_t, seed, drawIndexedIndirectCommand.vertexOffset ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndexedIndirectCommand.firstInstance ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DrawIndirectCommand { using NativeType = VkDrawIndirectCommand; @@ -27999,28 +26673,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDrawIndirectCommand const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDrawIndirectCommand const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDrawIndirectCommand &() VULKAN_HPP_NOEXCEPT + explicit operator VkDrawIndirectCommand &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( vertexCount, instanceCount, firstVertex, firstInstance ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrawIndirectCommand const & ) const = default; #else bool operator==( DrawIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( vertexCount == rhs.vertexCount ) && ( instanceCount == rhs.instanceCount ) && - ( firstVertex == rhs.firstVertex ) && ( firstInstance == rhs.firstInstance ); + return this->reflect() == rhs.reflect(); } bool operator!=( DrawIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -28037,25 +26720,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "DrawIndirectCommand is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DrawIndirectCommand const & drawIndirectCommand ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndirectCommand.vertexCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndirectCommand.instanceCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndirectCommand.firstVertex ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawIndirectCommand.firstInstance ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DrawMeshTasksIndirectCommandNV { using NativeType = VkDrawMeshTasksIndirectCommandNV; @@ -28098,27 +26762,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkDrawMeshTasksIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDrawMeshTasksIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDrawMeshTasksIndirectCommandNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkDrawMeshTasksIndirectCommandNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( taskCount, firstTask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrawMeshTasksIndirectCommandNV const & ) const = default; #else bool operator==( DrawMeshTasksIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( taskCount == rhs.taskCount ) && ( firstTask == rhs.firstTask ); + return this->reflect() == rhs.reflect(); } bool operator!=( DrawMeshTasksIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -28135,23 +26809,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "DrawMeshTasksIndirectCommandNV is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV const & drawMeshTasksIndirectCommandNV ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawMeshTasksIndirectCommandNV.taskCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drawMeshTasksIndirectCommandNV.firstTask ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DrmFormatModifierProperties2EXT { using NativeType = VkDrmFormatModifierProperties2EXT; @@ -28183,29 +26840,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkDrmFormatModifierProperties2EXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDrmFormatModifierProperties2EXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDrmFormatModifierProperties2EXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDrmFormatModifierProperties2EXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( drmFormatModifier, drmFormatModifierPlaneCount, drmFormatModifierTilingFeatures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrmFormatModifierProperties2EXT const & ) const = default; #else bool operator==( DrmFormatModifierProperties2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( drmFormatModifier == rhs.drmFormatModifier ) && - ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) && - ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures ); + return this->reflect() == rhs.reflect(); } bool operator!=( DrmFormatModifierProperties2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -28223,27 +26888,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "DrmFormatModifierProperties2EXT is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT const & drmFormatModifierProperties2EXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, drmFormatModifierProperties2EXT.drmFormatModifier ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drmFormatModifierProperties2EXT.drmFormatModifierPlaneCount ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR, - seed, - drmFormatModifierProperties2EXT.drmFormatModifierTilingFeatures ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DrmFormatModifierPropertiesEXT { using NativeType = VkDrmFormatModifierPropertiesEXT; @@ -28275,29 +26919,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkDrmFormatModifierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDrmFormatModifierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDrmFormatModifierPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDrmFormatModifierPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( drmFormatModifier, drmFormatModifierPlaneCount, drmFormatModifierTilingFeatures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrmFormatModifierPropertiesEXT const & ) const = default; #else bool operator==( DrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( drmFormatModifier == rhs.drmFormatModifier ) && - ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) && - ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures ); + return this->reflect() == rhs.reflect(); } bool operator!=( DrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -28315,25 +26967,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "DrmFormatModifierPropertiesEXT is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT const & drmFormatModifierPropertiesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, drmFormatModifierPropertiesEXT.drmFormatModifier ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drmFormatModifierPropertiesEXT.drmFormatModifierPlaneCount ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, drmFormatModifierPropertiesEXT.drmFormatModifierTilingFeatures ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DrmFormatModifierPropertiesList2EXT { using NativeType = VkDrmFormatModifierPropertiesList2EXT; @@ -28377,29 +27010,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkDrmFormatModifierPropertiesList2EXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDrmFormatModifierPropertiesList2EXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDrmFormatModifierPropertiesList2EXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDrmFormatModifierPropertiesList2EXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifierProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrmFormatModifierPropertiesList2EXT const & ) const = default; #else bool operator==( DrmFormatModifierPropertiesList2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( drmFormatModifierCount == rhs.drmFormatModifierCount ) && - ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( DrmFormatModifierPropertiesList2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -28424,27 +27068,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DrmFormatModifierPropertiesList2EXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT const & - drmFormatModifierPropertiesList2EXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, drmFormatModifierPropertiesList2EXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, drmFormatModifierPropertiesList2EXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drmFormatModifierPropertiesList2EXT.drmFormatModifierCount ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT *, - seed, - drmFormatModifierPropertiesList2EXT.pDrmFormatModifierProperties ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct DrmFormatModifierPropertiesListEXT { using NativeType = VkDrmFormatModifierPropertiesListEXT; @@ -28488,29 +27111,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkDrmFormatModifierPropertiesListEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkDrmFormatModifierPropertiesListEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkDrmFormatModifierPropertiesListEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkDrmFormatModifierPropertiesListEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifierProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrmFormatModifierPropertiesListEXT const & ) const = default; #else bool operator==( DrmFormatModifierPropertiesListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( drmFormatModifierCount == rhs.drmFormatModifierCount ) && - ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( DrmFormatModifierPropertiesListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -28535,27 +27169,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DrmFormatModifierPropertiesListEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT const & - drmFormatModifierPropertiesListEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, drmFormatModifierPropertiesListEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, drmFormatModifierPropertiesListEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, drmFormatModifierPropertiesListEXT.drmFormatModifierCount ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT *, - seed, - drmFormatModifierPropertiesListEXT.pDrmFormatModifierProperties ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct EventCreateInfo { using NativeType = VkEventCreateInfo; @@ -28598,27 +27211,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkEventCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkEventCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkEventCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkEventCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( EventCreateInfo const & ) const = default; #else bool operator==( EventCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( EventCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -28640,23 +27265,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = EventCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::EventCreateInfo const & eventCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, eventCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, eventCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::EventCreateFlags, seed, eventCreateInfo.flags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ExportFenceCreateInfo { using NativeType = VkExportFenceCreateInfo; @@ -28700,27 +27308,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkExportFenceCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExportFenceCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExportFenceCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkExportFenceCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportFenceCreateInfo const & ) const = default; #else bool operator==( ExportFenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExportFenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -28743,25 +27363,6 @@ namespace VULKAN_HPP_NAMESPACE }; using ExportFenceCreateInfoKHR = ExportFenceCreateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo const & exportFenceCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportFenceCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, exportFenceCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags, seed, exportFenceCreateInfo.handleTypes ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_WIN32_KHR ) struct ExportFenceWin32HandleInfoKHR { @@ -28823,28 +27424,41 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkExportFenceWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExportFenceWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExportFenceWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkExportFenceWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pAttributes, dwAccess, name ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportFenceWin32HandleInfoKHR const & ) const = default; # else bool operator==( ExportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && - ( dwAccess == rhs.dwAccess ) && ( name == rhs.name ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -28869,27 +27483,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = ExportFenceWin32HandleInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR const & exportFenceWin32HandleInfoKHR ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportFenceWin32HandleInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, exportFenceWin32HandleInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( const SECURITY_ATTRIBUTES *, seed, exportFenceWin32HandleInfoKHR.pAttributes ); - VULKAN_HPP_HASH_COMBINE( DWORD, seed, exportFenceWin32HandleInfoKHR.dwAccess ); - VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, exportFenceWin32HandleInfoKHR.name ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct ExportMemoryAllocateInfo @@ -28935,27 +27528,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkExportMemoryAllocateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExportMemoryAllocateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExportMemoryAllocateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkExportMemoryAllocateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportMemoryAllocateInfo const & ) const = default; #else bool operator==( ExportMemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExportMemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -28979,25 +27584,6 @@ namespace VULKAN_HPP_NAMESPACE }; using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo const & exportMemoryAllocateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportMemoryAllocateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, exportMemoryAllocateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags, seed, exportMemoryAllocateInfo.handleTypes ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ExportMemoryAllocateInfoNV { using NativeType = VkExportMemoryAllocateInfoNV; @@ -29042,27 +27628,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkExportMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExportMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExportMemoryAllocateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkExportMemoryAllocateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportMemoryAllocateInfoNV const & ) const = default; #else bool operator==( ExportMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExportMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -29085,25 +27683,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ExportMemoryAllocateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV const & exportMemoryAllocateInfoNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportMemoryAllocateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, exportMemoryAllocateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV, seed, exportMemoryAllocateInfoNV.handleTypes ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_WIN32_KHR ) struct ExportMemoryWin32HandleInfoKHR { @@ -29165,28 +27744,41 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkExportMemoryWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExportMemoryWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExportMemoryWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkExportMemoryWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pAttributes, dwAccess, name ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportMemoryWin32HandleInfoKHR const & ) const = default; # else bool operator==( ExportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && - ( dwAccess == rhs.dwAccess ) && ( name == rhs.name ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -29211,27 +27803,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = ExportMemoryWin32HandleInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR const & exportMemoryWin32HandleInfoKHR ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportMemoryWin32HandleInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, exportMemoryWin32HandleInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( const SECURITY_ATTRIBUTES *, seed, exportMemoryWin32HandleInfoKHR.pAttributes ); - VULKAN_HPP_HASH_COMBINE( DWORD, seed, exportMemoryWin32HandleInfoKHR.dwAccess ); - VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, exportMemoryWin32HandleInfoKHR.name ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #if defined( VK_USE_PLATFORM_WIN32_KHR ) @@ -29287,28 +27858,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkExportMemoryWin32HandleInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExportMemoryWin32HandleInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExportMemoryWin32HandleInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkExportMemoryWin32HandleInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pAttributes, dwAccess ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportMemoryWin32HandleInfoNV const & ) const = default; # else bool operator==( ExportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && - ( dwAccess == rhs.dwAccess ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -29332,26 +27915,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = ExportMemoryWin32HandleInfoNV; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV const & exportMemoryWin32HandleInfoNV ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportMemoryWin32HandleInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, exportMemoryWin32HandleInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( const SECURITY_ATTRIBUTES *, seed, exportMemoryWin32HandleInfoNV.pAttributes ); - VULKAN_HPP_HASH_COMBINE( DWORD, seed, exportMemoryWin32HandleInfoNV.dwAccess ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct ExportSemaphoreCreateInfo @@ -29398,27 +27961,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkExportSemaphoreCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExportSemaphoreCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExportSemaphoreCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkExportSemaphoreCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportSemaphoreCreateInfo const & ) const = default; #else bool operator==( ExportSemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExportSemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -29442,25 +28017,6 @@ namespace VULKAN_HPP_NAMESPACE }; using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo const & exportSemaphoreCreateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportSemaphoreCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, exportSemaphoreCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags, seed, exportSemaphoreCreateInfo.handleTypes ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_WIN32_KHR ) struct ExportSemaphoreWin32HandleInfoKHR { @@ -29523,28 +28079,41 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkExportSemaphoreWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExportSemaphoreWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExportSemaphoreWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkExportSemaphoreWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pAttributes, dwAccess, name ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportSemaphoreWin32HandleInfoKHR const & ) const = default; # else bool operator==( ExportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && - ( dwAccess == rhs.dwAccess ) && ( name == rhs.name ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -29569,27 +28138,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = ExportSemaphoreWin32HandleInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR const & - exportSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, exportSemaphoreWin32HandleInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, exportSemaphoreWin32HandleInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( const SECURITY_ATTRIBUTES *, seed, exportSemaphoreWin32HandleInfoKHR.pAttributes ); - VULKAN_HPP_HASH_COMBINE( DWORD, seed, exportSemaphoreWin32HandleInfoKHR.dwAccess ); - VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, exportSemaphoreWin32HandleInfoKHR.name ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct ExtensionProperties @@ -29619,27 +28167,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkExtensionProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExtensionProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExtensionProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkExtensionProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, uint32_t const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( extensionName, specVersion ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExtensionProperties const & ) const = default; #else bool operator==( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( extensionName == rhs.extensionName ) && ( specVersion == rhs.specVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -29654,26 +28212,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ExtensionProperties is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ExtensionProperties const & extensionProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, extensionProperties.extensionName[i] ); - } - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, extensionProperties.specVersion ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ExternalMemoryProperties { using NativeType = VkExternalMemoryProperties; @@ -29703,29 +28241,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkExternalMemoryProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExternalMemoryProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExternalMemoryProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkExternalMemoryProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( externalMemoryFeatures, exportFromImportedHandleTypes, compatibleHandleTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalMemoryProperties const & ) const = default; #else bool operator==( ExternalMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( externalMemoryFeatures == rhs.externalMemoryFeatures ) && - ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && - ( compatibleHandleTypes == rhs.compatibleHandleTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -29743,28 +28291,6 @@ namespace VULKAN_HPP_NAMESPACE "ExternalMemoryProperties is not nothrow_move_constructible!" ); using ExternalMemoryPropertiesKHR = ExternalMemoryProperties; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const & externalMemoryProperties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlags, seed, externalMemoryProperties.externalMemoryFeatures ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags, - seed, - externalMemoryProperties.exportFromImportedHandleTypes ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags, seed, externalMemoryProperties.compatibleHandleTypes ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ExternalBufferProperties { using NativeType = VkExternalBufferProperties; @@ -29793,28 +28319,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkExternalBufferProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExternalBufferProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExternalBufferProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkExternalBufferProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, externalMemoryProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalBufferProperties const & ) const = default; #else bool operator==( ExternalBufferProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( externalMemoryProperties == rhs.externalMemoryProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalBufferProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -29838,25 +28375,6 @@ namespace VULKAN_HPP_NAMESPACE }; using ExternalBufferPropertiesKHR = ExternalBufferProperties; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalBufferProperties const & externalBufferProperties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalBufferProperties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, externalBufferProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryProperties, seed, externalBufferProperties.externalMemoryProperties ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ExternalFenceProperties { using NativeType = VkExternalFenceProperties; @@ -29889,30 +28407,41 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkExternalFenceProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExternalFenceProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExternalFenceProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkExternalFenceProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, exportFromImportedHandleTypes, compatibleHandleTypes, externalFenceFeatures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalFenceProperties const & ) const = default; #else bool operator==( ExternalFenceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && - ( compatibleHandleTypes == rhs.compatibleHandleTypes ) && - ( externalFenceFeatures == rhs.externalFenceFeatures ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalFenceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -29938,29 +28467,6 @@ namespace VULKAN_HPP_NAMESPACE }; using ExternalFencePropertiesKHR = ExternalFenceProperties; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFenceProperties const & externalFenceProperties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalFenceProperties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, externalFenceProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags, seed, externalFenceProperties.exportFromImportedHandleTypes ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags, seed, externalFenceProperties.compatibleHandleTypes ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags, seed, externalFenceProperties.externalFenceFeatures ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_ANDROID_KHR ) struct ExternalFormatANDROID { @@ -30003,27 +28509,37 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkExternalFormatANDROID const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExternalFormatANDROID const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExternalFormatANDROID &() VULKAN_HPP_NOEXCEPT + explicit operator VkExternalFormatANDROID &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, externalFormat ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalFormatANDROID const & ) const = default; # else bool operator==( ExternalFormatANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalFormat == rhs.externalFormat ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalFormatANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -30044,25 +28560,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = ExternalFormatANDROID; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ExternalFormatANDROID const & externalFormatANDROID ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalFormatANDROID.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, externalFormatANDROID.pNext ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, externalFormatANDROID.externalFormat ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ struct ExternalImageFormatProperties @@ -30095,28 +28592,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkExternalImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExternalImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExternalImageFormatProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkExternalImageFormatProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, externalMemoryProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalImageFormatProperties const & ) const = default; #else bool operator==( ExternalImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( externalMemoryProperties == rhs.externalMemoryProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -30141,25 +28649,6 @@ namespace VULKAN_HPP_NAMESPACE }; using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties const & externalImageFormatProperties ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalImageFormatProperties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, externalImageFormatProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryProperties, seed, externalImageFormatProperties.externalMemoryProperties ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageFormatProperties { using NativeType = VkImageFormatProperties; @@ -30193,29 +28682,41 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageFormatProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageFormatProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( maxExtent, maxMipLevels, maxArrayLayers, sampleCounts, maxResourceSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageFormatProperties const & ) const = default; #else bool operator==( ImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( maxExtent == rhs.maxExtent ) && ( maxMipLevels == rhs.maxMipLevels ) && - ( maxArrayLayers == rhs.maxArrayLayers ) && ( sampleCounts == rhs.sampleCounts ) && - ( maxResourceSize == rhs.maxResourceSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -30233,26 +28734,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageFormatProperties is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties const & imageFormatProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageFormatProperties.maxExtent ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageFormatProperties.maxMipLevels ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageFormatProperties.maxArrayLayers ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, imageFormatProperties.sampleCounts ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, imageFormatProperties.maxResourceSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ExternalImageFormatPropertiesNV { using NativeType = VkExternalImageFormatPropertiesNV; @@ -30286,30 +28767,41 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkExternalImageFormatPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExternalImageFormatPropertiesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExternalImageFormatPropertiesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkExternalImageFormatPropertiesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + imageFormatProperties, externalMemoryFeatures, exportFromImportedHandleTypes, compatibleHandleTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalImageFormatPropertiesNV const & ) const = default; #else bool operator==( ExternalImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( imageFormatProperties == rhs.imageFormatProperties ) && - ( externalMemoryFeatures == rhs.externalMemoryFeatures ) && - ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && - ( compatibleHandleTypes == rhs.compatibleHandleTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -30328,33 +28820,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "ExternalImageFormatPropertiesNV is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV const & externalImageFormatPropertiesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ImageFormatProperties, seed, externalImageFormatPropertiesNV.imageFormatProperties ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagsNV, - seed, - externalImageFormatPropertiesNV.externalMemoryFeatures ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV, - seed, - externalImageFormatPropertiesNV.exportFromImportedHandleTypes ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV, - seed, - externalImageFormatPropertiesNV.compatibleHandleTypes ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ExternalMemoryBufferCreateInfo { using NativeType = VkExternalMemoryBufferCreateInfo; @@ -30400,27 +28865,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkExternalMemoryBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExternalMemoryBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExternalMemoryBufferCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkExternalMemoryBufferCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalMemoryBufferCreateInfo const & ) const = default; #else bool operator==( ExternalMemoryBufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalMemoryBufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -30445,25 +28922,6 @@ namespace VULKAN_HPP_NAMESPACE }; using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo const & externalMemoryBufferCreateInfo ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalMemoryBufferCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, externalMemoryBufferCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags, seed, externalMemoryBufferCreateInfo.handleTypes ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ExternalMemoryImageCreateInfo { using NativeType = VkExternalMemoryImageCreateInfo; @@ -30509,27 +28967,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkExternalMemoryImageCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExternalMemoryImageCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExternalMemoryImageCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkExternalMemoryImageCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalMemoryImageCreateInfo const & ) const = default; #else bool operator==( ExternalMemoryImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalMemoryImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -30554,25 +29024,6 @@ namespace VULKAN_HPP_NAMESPACE }; using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo const & externalMemoryImageCreateInfo ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalMemoryImageCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, externalMemoryImageCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags, seed, externalMemoryImageCreateInfo.handleTypes ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ExternalMemoryImageCreateInfoNV { using NativeType = VkExternalMemoryImageCreateInfoNV; @@ -30618,27 +29069,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkExternalMemoryImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExternalMemoryImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExternalMemoryImageCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkExternalMemoryImageCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalMemoryImageCreateInfoNV const & ) const = default; #else bool operator==( ExternalMemoryImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalMemoryImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -30662,26 +29125,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ExternalMemoryImageCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV const & externalMemoryImageCreateInfoNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalMemoryImageCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, externalMemoryImageCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV, seed, externalMemoryImageCreateInfoNV.handleTypes ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ExternalSemaphoreProperties { using NativeType = VkExternalSemaphoreProperties; @@ -30715,30 +29158,41 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkExternalSemaphoreProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkExternalSemaphoreProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkExternalSemaphoreProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkExternalSemaphoreProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, exportFromImportedHandleTypes, compatibleHandleTypes, externalSemaphoreFeatures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalSemaphoreProperties const & ) const = default; #else bool operator==( ExternalSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && - ( compatibleHandleTypes == rhs.compatibleHandleTypes ) && - ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -30765,31 +29219,6 @@ namespace VULKAN_HPP_NAMESPACE }; using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties const & externalSemaphoreProperties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, externalSemaphoreProperties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, externalSemaphoreProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags, - seed, - externalSemaphoreProperties.exportFromImportedHandleTypes ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags, seed, externalSemaphoreProperties.compatibleHandleTypes ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlags, - seed, - externalSemaphoreProperties.externalSemaphoreFeatures ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct FenceCreateInfo { using NativeType = VkFenceCreateInfo; @@ -30832,27 +29261,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkFenceCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkFenceCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkFenceCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkFenceCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FenceCreateInfo const & ) const = default; #else bool operator==( FenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( FenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -30874,23 +29315,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = FenceCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & fenceCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, fenceCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, fenceCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FenceCreateFlags, seed, fenceCreateInfo.flags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct FenceGetFdInfoKHR { using NativeType = VkFenceGetFdInfoKHR; @@ -30943,28 +29367,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkFenceGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkFenceGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkFenceGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkFenceGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fence, handleType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FenceGetFdInfoKHR const & ) const = default; #else bool operator==( FenceGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( FenceGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -30988,25 +29424,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = FenceGetFdInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR const & fenceGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, fenceGetFdInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, fenceGetFdInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, fenceGetFdInfoKHR.fence ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, fenceGetFdInfoKHR.handleType ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_WIN32_KHR ) struct FenceGetWin32HandleInfoKHR { @@ -31062,28 +29479,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkFenceGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkFenceGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkFenceGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkFenceGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fence, handleType ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FenceGetWin32HandleInfoKHR const & ) const = default; # else bool operator==( FenceGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( FenceGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -31107,27 +29536,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = FenceGetWin32HandleInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR const & fenceGetWin32HandleInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, fenceGetWin32HandleInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, fenceGetWin32HandleInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, fenceGetWin32HandleInfoKHR.fence ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, fenceGetWin32HandleInfoKHR.handleType ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct FilterCubicImageViewImageFormatPropertiesEXT @@ -31166,28 +29574,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkFilterCubicImageViewImageFormatPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkFilterCubicImageViewImageFormatPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkFilterCubicImageViewImageFormatPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkFilterCubicImageViewImageFormatPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, filterCubic, filterCubicMinmax ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FilterCubicImageViewImageFormatPropertiesEXT const & ) const = default; #else bool operator==( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( filterCubic == rhs.filterCubic ) && - ( filterCubicMinmax == rhs.filterCubicMinmax ); + return this->reflect() == rhs.reflect(); } bool operator!=( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -31213,28 +29633,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = FilterCubicImageViewImageFormatPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT const & - filterCubicImageViewImageFormatPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, filterCubicImageViewImageFormatPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, filterCubicImageViewImageFormatPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubic ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubicMinmax ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct FormatProperties { using NativeType = VkFormatProperties; @@ -31264,28 +29662,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkFormatProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkFormatProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkFormatProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkFormatProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( linearTilingFeatures, optimalTilingFeatures, bufferFeatures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FormatProperties const & ) const = default; #else bool operator==( FormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( linearTilingFeatures == rhs.linearTilingFeatures ) && - ( optimalTilingFeatures == rhs.optimalTilingFeatures ) && ( bufferFeatures == rhs.bufferFeatures ); + return this->reflect() == rhs.reflect(); } bool operator!=( FormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -31301,23 +29710,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "FormatProperties is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties const & formatProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, formatProperties.linearTilingFeatures ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, formatProperties.optimalTilingFeatures ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, formatProperties.bufferFeatures ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct FormatProperties2 { using NativeType = VkFormatProperties2; @@ -31346,27 +29738,38 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkFormatProperties2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkFormatProperties2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std:: + tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, formatProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FormatProperties2 const & ) const = default; #else bool operator==( FormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatProperties == rhs.formatProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( FormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -31389,23 +29792,6 @@ namespace VULKAN_HPP_NAMESPACE }; using FormatProperties2KHR = FormatProperties2; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties2 const & formatProperties2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, formatProperties2.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, formatProperties2.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatProperties, seed, formatProperties2.formatProperties ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct FormatProperties3KHR { using NativeType = VkFormatProperties3KHR; @@ -31438,28 +29824,41 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkFormatProperties3KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkFormatProperties3KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkFormatProperties3KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkFormatProperties3KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, linearTilingFeatures, optimalTilingFeatures, bufferFeatures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FormatProperties3KHR const & ) const = default; #else bool operator==( FormatProperties3KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( linearTilingFeatures == rhs.linearTilingFeatures ) && - ( optimalTilingFeatures == rhs.optimalTilingFeatures ) && ( bufferFeatures == rhs.bufferFeatures ); + return this->reflect() == rhs.reflect(); } bool operator!=( FormatProperties3KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -31483,28 +29882,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = FormatProperties3KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::FormatProperties3KHR const & formatProperties3KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, formatProperties3KHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, formatProperties3KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR, seed, formatProperties3KHR.linearTilingFeatures ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR, seed, formatProperties3KHR.optimalTilingFeatures ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR, seed, formatProperties3KHR.bufferFeatures ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct FragmentShadingRateAttachmentInfoKHR { using NativeType = VkFragmentShadingRateAttachmentInfoKHR; @@ -31561,29 +29938,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkFragmentShadingRateAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkFragmentShadingRateAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkFragmentShadingRateAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkFragmentShadingRateAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pFragmentShadingRateAttachment, shadingRateAttachmentTexelSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FragmentShadingRateAttachmentInfoKHR const & ) const = default; #else bool operator==( FragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( pFragmentShadingRateAttachment == rhs.pFragmentShadingRateAttachment ) && - ( shadingRateAttachmentTexelSize == rhs.shadingRateAttachmentTexelSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( FragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -31608,28 +29996,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = FragmentShadingRateAttachmentInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR const & - fragmentShadingRateAttachmentInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, fragmentShadingRateAttachmentInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, fragmentShadingRateAttachmentInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AttachmentReference2 *, - seed, - fragmentShadingRateAttachmentInfoKHR.pFragmentShadingRateAttachment ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Extent2D, seed, fragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct FramebufferAttachmentImageInfo { using NativeType = VkFramebufferAttachmentImageInfo; @@ -31755,29 +30121,45 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkFramebufferAttachmentImageInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkFramebufferAttachmentImageInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkFramebufferAttachmentImageInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkFramebufferAttachmentImageInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, usage, width, height, layerCount, viewFormatCount, pViewFormats ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FramebufferAttachmentImageInfo const & ) const = default; #else bool operator==( FramebufferAttachmentImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( usage == rhs.usage ) && - ( width == rhs.width ) && ( height == rhs.height ) && ( layerCount == rhs.layerCount ) && - ( viewFormatCount == rhs.viewFormatCount ) && ( pViewFormats == rhs.pViewFormats ); + return this->reflect() == rhs.reflect(); } bool operator!=( FramebufferAttachmentImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -31808,30 +30190,6 @@ namespace VULKAN_HPP_NAMESPACE }; using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo const & framebufferAttachmentImageInfo ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, framebufferAttachmentImageInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, framebufferAttachmentImageInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageCreateFlags, seed, framebufferAttachmentImageInfo.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, framebufferAttachmentImageInfo.usage ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentImageInfo.width ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentImageInfo.height ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentImageInfo.layerCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentImageInfo.viewFormatCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Format *, seed, framebufferAttachmentImageInfo.pViewFormats ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct FramebufferAttachmentsCreateInfo { using NativeType = VkFramebufferAttachmentsCreateInfo; @@ -31906,29 +30264,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkFramebufferAttachmentsCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkFramebufferAttachmentsCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkFramebufferAttachmentsCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkFramebufferAttachmentsCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, attachmentImageInfoCount, pAttachmentImageInfos ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FramebufferAttachmentsCreateInfo const & ) const = default; #else bool operator==( FramebufferAttachmentsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( attachmentImageInfoCount == rhs.attachmentImageInfoCount ) && - ( pAttachmentImageInfos == rhs.pAttachmentImageInfos ); + return this->reflect() == rhs.reflect(); } bool operator!=( FramebufferAttachmentsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -31954,28 +30323,6 @@ namespace VULKAN_HPP_NAMESPACE }; using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo const & framebufferAttachmentsCreateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, framebufferAttachmentsCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, framebufferAttachmentsCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferAttachmentsCreateInfo.attachmentImageInfoCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo *, - seed, - framebufferAttachmentsCreateInfo.pAttachmentImageInfos ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct FramebufferCreateInfo { using NativeType = VkFramebufferCreateInfo; @@ -32097,30 +30444,45 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkFramebufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkFramebufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkFramebufferCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkFramebufferCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, renderPass, attachmentCount, pAttachments, width, height, layers ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FramebufferCreateInfo const & ) const = default; #else bool operator==( FramebufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( renderPass == rhs.renderPass ) && ( attachmentCount == rhs.attachmentCount ) && - ( pAttachments == rhs.pAttachments ) && ( width == rhs.width ) && ( height == rhs.height ) && - ( layers == rhs.layers ); + return this->reflect() == rhs.reflect(); } bool operator!=( FramebufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -32148,30 +30510,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = FramebufferCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & framebufferCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, framebufferCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, framebufferCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FramebufferCreateFlags, seed, framebufferCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPass, seed, framebufferCreateInfo.renderPass ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferCreateInfo.attachmentCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageView *, seed, framebufferCreateInfo.pAttachments ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferCreateInfo.width ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferCreateInfo.height ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, framebufferCreateInfo.layers ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct FramebufferMixedSamplesCombinationNV { using NativeType = VkFramebufferMixedSamplesCombinationNV; @@ -32211,30 +30549,42 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkFramebufferMixedSamplesCombinationNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkFramebufferMixedSamplesCombinationNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkFramebufferMixedSamplesCombinationNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkFramebufferMixedSamplesCombinationNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, coverageReductionMode, rasterizationSamples, depthStencilSamples, colorSamples ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FramebufferMixedSamplesCombinationNV const & ) const = default; #else bool operator==( FramebufferMixedSamplesCombinationNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( coverageReductionMode == rhs.coverageReductionMode ) && - ( rasterizationSamples == rhs.rasterizationSamples ) && - ( depthStencilSamples == rhs.depthStencilSamples ) && ( colorSamples == rhs.colorSamples ); + return this->reflect() == rhs.reflect(); } bool operator!=( FramebufferMixedSamplesCombinationNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -32262,31 +30612,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = FramebufferMixedSamplesCombinationNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV const & - framebufferMixedSamplesCombinationNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, framebufferMixedSamplesCombinationNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, framebufferMixedSamplesCombinationNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::CoverageReductionModeNV, seed, framebufferMixedSamplesCombinationNV.coverageReductionMode ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, framebufferMixedSamplesCombinationNV.rasterizationSamples ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, framebufferMixedSamplesCombinationNV.depthStencilSamples ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, framebufferMixedSamplesCombinationNV.colorSamples ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct IndirectCommandsStreamNV { using NativeType = VkIndirectCommandsStreamNV; @@ -32329,27 +30654,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkIndirectCommandsStreamNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkIndirectCommandsStreamNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkIndirectCommandsStreamNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkIndirectCommandsStreamNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( buffer, offset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( IndirectCommandsStreamNV const & ) const = default; #else bool operator==( IndirectCommandsStreamNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( buffer == rhs.buffer ) && ( offset == rhs.offset ); + return this->reflect() == rhs.reflect(); } bool operator!=( IndirectCommandsStreamNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -32365,23 +30700,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "IndirectCommandsStreamNV is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV const & indirectCommandsStreamNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, indirectCommandsStreamNV.buffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, indirectCommandsStreamNV.offset ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct GeneratedCommandsInfoNV { using NativeType = VkGeneratedCommandsInfoNV; @@ -32573,35 +30891,65 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkGeneratedCommandsInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkGeneratedCommandsInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkGeneratedCommandsInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkGeneratedCommandsInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + pipelineBindPoint, + pipeline, + indirectCommandsLayout, + streamCount, + pStreams, + sequencesCount, + preprocessBuffer, + preprocessOffset, + preprocessSize, + sequencesCountBuffer, + sequencesCountOffset, + sequencesIndexBuffer, + sequencesIndexOffset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GeneratedCommandsInfoNV const & ) const = default; #else bool operator==( GeneratedCommandsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && - ( pipeline == rhs.pipeline ) && ( indirectCommandsLayout == rhs.indirectCommandsLayout ) && - ( streamCount == rhs.streamCount ) && ( pStreams == rhs.pStreams ) && - ( sequencesCount == rhs.sequencesCount ) && ( preprocessBuffer == rhs.preprocessBuffer ) && - ( preprocessOffset == rhs.preprocessOffset ) && ( preprocessSize == rhs.preprocessSize ) && - ( sequencesCountBuffer == rhs.sequencesCountBuffer ) && - ( sequencesCountOffset == rhs.sequencesCountOffset ) && - ( sequencesIndexBuffer == rhs.sequencesIndexBuffer ) && - ( sequencesIndexOffset == rhs.sequencesIndexOffset ); + return this->reflect() == rhs.reflect(); } bool operator!=( GeneratedCommandsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -32636,38 +30984,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = GeneratedCommandsInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV const & generatedCommandsInfoNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, generatedCommandsInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, generatedCommandsInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, generatedCommandsInfoNV.pipelineBindPoint ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, generatedCommandsInfoNV.pipeline ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, seed, generatedCommandsInfoNV.indirectCommandsLayout ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, generatedCommandsInfoNV.streamCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV *, seed, generatedCommandsInfoNV.pStreams ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, generatedCommandsInfoNV.sequencesCount ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, generatedCommandsInfoNV.preprocessBuffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, generatedCommandsInfoNV.preprocessOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, generatedCommandsInfoNV.preprocessSize ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, generatedCommandsInfoNV.sequencesCountBuffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, generatedCommandsInfoNV.sequencesCountOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, generatedCommandsInfoNV.sequencesIndexBuffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, generatedCommandsInfoNV.sequencesIndexOffset ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct GeneratedCommandsMemoryRequirementsInfoNV { using NativeType = VkGeneratedCommandsMemoryRequirementsInfoNV; @@ -32745,29 +31061,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkGeneratedCommandsMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkGeneratedCommandsMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkGeneratedCommandsMemoryRequirementsInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkGeneratedCommandsMemoryRequirementsInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineBindPoint, pipeline, indirectCommandsLayout, maxSequencesCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GeneratedCommandsMemoryRequirementsInfoNV const & ) const = default; #else bool operator==( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && - ( pipeline == rhs.pipeline ) && ( indirectCommandsLayout == rhs.indirectCommandsLayout ) && - ( maxSequencesCount == rhs.maxSequencesCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -32795,31 +31124,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = GeneratedCommandsMemoryRequirementsInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV const & - generatedCommandsMemoryRequirementsInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, generatedCommandsMemoryRequirementsInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, generatedCommandsMemoryRequirementsInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, generatedCommandsMemoryRequirementsInfoNV.pipelineBindPoint ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, generatedCommandsMemoryRequirementsInfoNV.pipeline ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, - seed, - generatedCommandsMemoryRequirementsInfoNV.indirectCommandsLayout ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, generatedCommandsMemoryRequirementsInfoNV.maxSequencesCount ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct VertexInputBindingDescription { using NativeType = VkVertexInputBindingDescription; @@ -32873,27 +31177,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVertexInputBindingDescription const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVertexInputBindingDescription const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVertexInputBindingDescription &() VULKAN_HPP_NOEXCEPT + explicit operator VkVertexInputBindingDescription &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( binding, stride, inputRate ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VertexInputBindingDescription const & ) const = default; #else bool operator==( VertexInputBindingDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( binding == rhs.binding ) && ( stride == rhs.stride ) && ( inputRate == rhs.inputRate ); + return this->reflect() == rhs.reflect(); } bool operator!=( VertexInputBindingDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -32911,24 +31225,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "VertexInputBindingDescription is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription const & vertexInputBindingDescription ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription.binding ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription.stride ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VertexInputRate, seed, vertexInputBindingDescription.inputRate ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct VertexInputAttributeDescription { using NativeType = VkVertexInputAttributeDescription; @@ -32989,28 +31285,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVertexInputAttributeDescription const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVertexInputAttributeDescription const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVertexInputAttributeDescription &() VULKAN_HPP_NOEXCEPT + explicit operator VkVertexInputAttributeDescription &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( location, binding, format, offset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VertexInputAttributeDescription const & ) const = default; #else bool operator==( VertexInputAttributeDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( location == rhs.location ) && ( binding == rhs.binding ) && ( format == rhs.format ) && - ( offset == rhs.offset ); + return this->reflect() == rhs.reflect(); } bool operator!=( VertexInputAttributeDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -33029,26 +31334,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "VertexInputAttributeDescription is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription const & vertexInputAttributeDescription ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription.location ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription.binding ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, vertexInputAttributeDescription.format ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription.offset ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineVertexInputStateCreateInfo { using NativeType = VkPipelineVertexInputStateCreateInfo; @@ -33170,31 +31455,49 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineVertexInputStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineVertexInputStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineVertexInputStateCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineVertexInputStateCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + vertexBindingDescriptionCount, + pVertexBindingDescriptions, + vertexAttributeDescriptionCount, + pVertexAttributeDescriptions ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineVertexInputStateCreateInfo const & ) const = default; #else bool operator==( PipelineVertexInputStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( vertexBindingDescriptionCount == rhs.vertexBindingDescriptionCount ) && - ( pVertexBindingDescriptions == rhs.pVertexBindingDescriptions ) && - ( vertexAttributeDescriptionCount == rhs.vertexAttributeDescriptionCount ) && - ( pVertexAttributeDescriptions == rhs.pVertexAttributeDescriptions ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineVertexInputStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -33222,33 +31525,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineVertexInputStateCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo const & - pipelineVertexInputStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineVertexInputStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineVertexInputStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlags, seed, pipelineVertexInputStateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription *, - seed, - pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription *, - seed, - pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineInputAssemblyStateCreateInfo { using NativeType = VkPipelineInputAssemblyStateCreateInfo; @@ -33314,28 +31590,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineInputAssemblyStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineInputAssemblyStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineInputAssemblyStateCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineInputAssemblyStateCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, topology, primitiveRestartEnable ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineInputAssemblyStateCreateInfo const & ) const = default; #else bool operator==( PipelineInputAssemblyStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( topology == rhs.topology ) && ( primitiveRestartEnable == rhs.primitiveRestartEnable ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineInputAssemblyStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -33361,29 +31650,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineInputAssemblyStateCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo const & - pipelineInputAssemblyStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineInputAssemblyStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineInputAssemblyStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags, seed, pipelineInputAssemblyStateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PrimitiveTopology, seed, pipelineInputAssemblyStateCreateInfo.topology ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineTessellationStateCreateInfo { using NativeType = VkPipelineTessellationStateCreateInfo; @@ -33440,28 +31706,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineTessellationStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineTessellationStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineTessellationStateCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineTessellationStateCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, patchControlPoints ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineTessellationStateCreateInfo const & ) const = default; #else bool operator==( PipelineTessellationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( patchControlPoints == rhs.patchControlPoints ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineTessellationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -33486,26 +31764,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineTessellationStateCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo const & - pipelineTessellationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineTessellationStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineTessellationStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlags, seed, pipelineTessellationStateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineTessellationStateCreateInfo.patchControlPoints ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineViewportStateCreateInfo { using NativeType = VkPipelineViewportStateCreateInfo; @@ -33622,29 +31880,43 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineViewportStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineViewportStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineViewportStateCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineViewportStateCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, viewportCount, pViewports, scissorCount, pScissors ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportStateCreateInfo const & ) const = default; #else bool operator==( PipelineViewportStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( viewportCount == rhs.viewportCount ) && ( pViewports == rhs.pViewports ) && - ( scissorCount == rhs.scissorCount ) && ( pScissors == rhs.pScissors ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineViewportStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -33672,30 +31944,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineViewportStateCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo const & pipelineViewportStateCreateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlags, seed, pipelineViewportStateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportStateCreateInfo.viewportCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Viewport *, seed, pipelineViewportStateCreateInfo.pViewports ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportStateCreateInfo.scissorCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Rect2D *, seed, pipelineViewportStateCreateInfo.pScissors ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineRasterizationStateCreateInfo { using NativeType = VkPipelineRasterizationStateCreateInfo; @@ -33832,33 +32080,61 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineRasterizationStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineRasterizationStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineRasterizationStateCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineRasterizationStateCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + depthClampEnable, + rasterizerDiscardEnable, + polygonMode, + cullMode, + frontFace, + depthBiasEnable, + depthBiasConstantFactor, + depthBiasClamp, + depthBiasSlopeFactor, + lineWidth ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationStateCreateInfo const & ) const = default; #else bool operator==( PipelineRasterizationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( depthClampEnable == rhs.depthClampEnable ) && - ( rasterizerDiscardEnable == rhs.rasterizerDiscardEnable ) && ( polygonMode == rhs.polygonMode ) && - ( cullMode == rhs.cullMode ) && ( frontFace == rhs.frontFace ) && - ( depthBiasEnable == rhs.depthBiasEnable ) && ( depthBiasConstantFactor == rhs.depthBiasConstantFactor ) && - ( depthBiasClamp == rhs.depthBiasClamp ) && ( depthBiasSlopeFactor == rhs.depthBiasSlopeFactor ) && - ( lineWidth == rhs.lineWidth ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineRasterizationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -33892,38 +32168,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineRasterizationStateCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo const & - pipelineRasterizationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlags, seed, pipelineRasterizationStateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationStateCreateInfo.depthClampEnable ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PolygonMode, seed, pipelineRasterizationStateCreateInfo.polygonMode ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CullModeFlags, seed, pipelineRasterizationStateCreateInfo.cullMode ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FrontFace, seed, pipelineRasterizationStateCreateInfo.frontFace ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationStateCreateInfo.depthBiasEnable ); - VULKAN_HPP_HASH_COMBINE( float, seed, pipelineRasterizationStateCreateInfo.depthBiasConstantFactor ); - VULKAN_HPP_HASH_COMBINE( float, seed, pipelineRasterizationStateCreateInfo.depthBiasClamp ); - VULKAN_HPP_HASH_COMBINE( float, seed, pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor ); - VULKAN_HPP_HASH_COMBINE( float, seed, pipelineRasterizationStateCreateInfo.lineWidth ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineMultisampleStateCreateInfo { using NativeType = VkPipelineMultisampleStateCreateInfo; @@ -34025,31 +32269,53 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineMultisampleStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineMultisampleStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineMultisampleStateCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineMultisampleStateCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + rasterizationSamples, + sampleShadingEnable, + minSampleShading, + pSampleMask, + alphaToCoverageEnable, + alphaToOneEnable ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineMultisampleStateCreateInfo const & ) const = default; #else bool operator==( PipelineMultisampleStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( rasterizationSamples == rhs.rasterizationSamples ) && - ( sampleShadingEnable == rhs.sampleShadingEnable ) && ( minSampleShading == rhs.minSampleShading ) && - ( pSampleMask == rhs.pSampleMask ) && ( alphaToCoverageEnable == rhs.alphaToCoverageEnable ) && - ( alphaToOneEnable == rhs.alphaToOneEnable ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineMultisampleStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -34079,35 +32345,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineMultisampleStateCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo const & - pipelineMultisampleStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineMultisampleStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineMultisampleStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags, seed, pipelineMultisampleStateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, pipelineMultisampleStateCreateInfo.rasterizationSamples ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineMultisampleStateCreateInfo.sampleShadingEnable ); - VULKAN_HPP_HASH_COMBINE( float, seed, pipelineMultisampleStateCreateInfo.minSampleShading ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::SampleMask *, seed, pipelineMultisampleStateCreateInfo.pSampleMask ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineMultisampleStateCreateInfo.alphaToCoverageEnable ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineMultisampleStateCreateInfo.alphaToOneEnable ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct StencilOpState { using NativeType = VkStencilOpState; @@ -34191,29 +32428,43 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkStencilOpState const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkStencilOpState const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkStencilOpState &() VULKAN_HPP_NOEXCEPT + explicit operator VkStencilOpState &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( failOp, passOp, depthFailOp, compareOp, compareMask, writeMask, reference ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( StencilOpState const & ) const = default; #else bool operator==( StencilOpState const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( failOp == rhs.failOp ) && ( passOp == rhs.passOp ) && ( depthFailOp == rhs.depthFailOp ) && - ( compareOp == rhs.compareOp ) && ( compareMask == rhs.compareMask ) && ( writeMask == rhs.writeMask ) && - ( reference == rhs.reference ); + return this->reflect() == rhs.reflect(); } bool operator!=( StencilOpState const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -34233,27 +32484,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "StencilOpState is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::StencilOpState const & stencilOpState ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOp, seed, stencilOpState.failOp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOp, seed, stencilOpState.passOp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOp, seed, stencilOpState.depthFailOp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CompareOp, seed, stencilOpState.compareOp ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, stencilOpState.compareMask ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, stencilOpState.writeMask ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, stencilOpState.reference ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineDepthStencilStateCreateInfo { using NativeType = VkPipelineDepthStencilStateCreateInfo; @@ -34382,31 +32612,59 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineDepthStencilStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineDepthStencilStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineDepthStencilStateCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineDepthStencilStateCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + depthTestEnable, + depthWriteEnable, + depthCompareOp, + depthBoundsTestEnable, + stencilTestEnable, + front, + back, + minDepthBounds, + maxDepthBounds ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineDepthStencilStateCreateInfo const & ) const = default; #else bool operator==( PipelineDepthStencilStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( depthTestEnable == rhs.depthTestEnable ) && ( depthWriteEnable == rhs.depthWriteEnable ) && - ( depthCompareOp == rhs.depthCompareOp ) && ( depthBoundsTestEnable == rhs.depthBoundsTestEnable ) && - ( stencilTestEnable == rhs.stencilTestEnable ) && ( front == rhs.front ) && ( back == rhs.back ) && - ( minDepthBounds == rhs.minDepthBounds ) && ( maxDepthBounds == rhs.maxDepthBounds ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineDepthStencilStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -34439,37 +32697,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineDepthStencilStateCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo const & - pipelineDepthStencilStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineDepthStencilStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineDepthStencilStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags, seed, pipelineDepthStencilStateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineDepthStencilStateCreateInfo.depthTestEnable ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineDepthStencilStateCreateInfo.depthWriteEnable ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::CompareOp, seed, pipelineDepthStencilStateCreateInfo.depthCompareOp ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineDepthStencilStateCreateInfo.stencilTestEnable ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOpState, seed, pipelineDepthStencilStateCreateInfo.front ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StencilOpState, seed, pipelineDepthStencilStateCreateInfo.back ); - VULKAN_HPP_HASH_COMBINE( float, seed, pipelineDepthStencilStateCreateInfo.minDepthBounds ); - VULKAN_HPP_HASH_COMBINE( float, seed, pipelineDepthStencilStateCreateInfo.maxDepthBounds ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineColorBlendAttachmentState { using NativeType = VkPipelineColorBlendAttachmentState; @@ -34569,30 +32796,51 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineColorBlendAttachmentState const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineColorBlendAttachmentState const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineColorBlendAttachmentState &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineColorBlendAttachmentState &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( blendEnable, + srcColorBlendFactor, + dstColorBlendFactor, + colorBlendOp, + srcAlphaBlendFactor, + dstAlphaBlendFactor, + alphaBlendOp, + colorWriteMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineColorBlendAttachmentState const & ) const = default; #else bool operator==( PipelineColorBlendAttachmentState const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( blendEnable == rhs.blendEnable ) && ( srcColorBlendFactor == rhs.srcColorBlendFactor ) && - ( dstColorBlendFactor == rhs.dstColorBlendFactor ) && ( colorBlendOp == rhs.colorBlendOp ) && - ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor ) && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor ) && - ( alphaBlendOp == rhs.alphaBlendOp ) && ( colorWriteMask == rhs.colorWriteMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineColorBlendAttachmentState const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -34615,34 +32863,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "PipelineColorBlendAttachmentState is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState const & - pipelineColorBlendAttachmentState ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineColorBlendAttachmentState.blendEnable ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::BlendFactor, seed, pipelineColorBlendAttachmentState.srcColorBlendFactor ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::BlendFactor, seed, pipelineColorBlendAttachmentState.dstColorBlendFactor ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BlendOp, seed, pipelineColorBlendAttachmentState.colorBlendOp ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::BlendFactor, seed, pipelineColorBlendAttachmentState.srcAlphaBlendFactor ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::BlendFactor, seed, pipelineColorBlendAttachmentState.dstAlphaBlendFactor ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BlendOp, seed, pipelineColorBlendAttachmentState.alphaBlendOp ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ColorComponentFlags, seed, pipelineColorBlendAttachmentState.colorWriteMask ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineColorBlendStateCreateInfo { using NativeType = VkPipelineColorBlendStateCreateInfo; @@ -34762,30 +32982,44 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineColorBlendStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineColorBlendStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineColorBlendStateCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineColorBlendStateCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, logicOpEnable, logicOp, attachmentCount, pAttachments, blendConstants ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineColorBlendStateCreateInfo const & ) const = default; #else bool operator==( PipelineColorBlendStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( logicOpEnable == rhs.logicOpEnable ) && ( logicOp == rhs.logicOp ) && - ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ) && - ( blendConstants == rhs.blendConstants ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineColorBlendStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -34814,35 +33048,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineColorBlendStateCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo const & - pipelineColorBlendStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineColorBlendStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineColorBlendStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags, seed, pipelineColorBlendStateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineColorBlendStateCreateInfo.logicOpEnable ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::LogicOp, seed, pipelineColorBlendStateCreateInfo.logicOp ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineColorBlendStateCreateInfo.attachmentCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState *, - seed, - pipelineColorBlendStateCreateInfo.pAttachments ); - for ( size_t i = 0; i < 4; ++i ) - { - VULKAN_HPP_HASH_COMBINE( float, seed, pipelineColorBlendStateCreateInfo.blendConstants[i] ); - } - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineDynamicStateCreateInfo { using NativeType = VkPipelineDynamicStateCreateInfo; @@ -34927,28 +33132,41 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineDynamicStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineDynamicStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineDynamicStateCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineDynamicStateCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, dynamicStateCount, pDynamicStates ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineDynamicStateCreateInfo const & ) const = default; #else bool operator==( PipelineDynamicStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( dynamicStateCount == rhs.dynamicStateCount ) && ( pDynamicStates == rhs.pDynamicStates ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineDynamicStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -34974,28 +33192,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineDynamicStateCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo const & pipelineDynamicStateCreateInfo ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineDynamicStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineDynamicStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags, seed, pipelineDynamicStateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineDynamicStateCreateInfo.dynamicStateCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::DynamicState *, seed, pipelineDynamicStateCreateInfo.pDynamicStates ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct GraphicsPipelineCreateInfo { using NativeType = VkGraphicsPipelineCreateInfo; @@ -35232,35 +33428,73 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkGraphicsPipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkGraphicsPipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkGraphicsPipelineCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkGraphicsPipelineCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + stageCount, + pStages, + pVertexInputState, + pInputAssemblyState, + pTessellationState, + pViewportState, + pRasterizationState, + pMultisampleState, + pDepthStencilState, + pColorBlendState, + pDynamicState, + layout, + renderPass, + subpass, + basePipelineHandle, + basePipelineIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GraphicsPipelineCreateInfo const & ) const = default; #else bool operator==( GraphicsPipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && - ( pVertexInputState == rhs.pVertexInputState ) && ( pInputAssemblyState == rhs.pInputAssemblyState ) && - ( pTessellationState == rhs.pTessellationState ) && ( pViewportState == rhs.pViewportState ) && - ( pRasterizationState == rhs.pRasterizationState ) && ( pMultisampleState == rhs.pMultisampleState ) && - ( pDepthStencilState == rhs.pDepthStencilState ) && ( pColorBlendState == rhs.pColorBlendState ) && - ( pDynamicState == rhs.pDynamicState ) && ( layout == rhs.layout ) && ( renderPass == rhs.renderPass ) && - ( subpass == rhs.subpass ) && ( basePipelineHandle == rhs.basePipelineHandle ) && - ( basePipelineIndex == rhs.basePipelineIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( GraphicsPipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -35299,57 +33533,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = GraphicsPipelineCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & graphicsPipelineCreateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, graphicsPipelineCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, graphicsPipelineCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreateFlags, seed, graphicsPipelineCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsPipelineCreateInfo.stageCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo *, seed, graphicsPipelineCreateInfo.pStages ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo *, - seed, - graphicsPipelineCreateInfo.pVertexInputState ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo *, - seed, - graphicsPipelineCreateInfo.pInputAssemblyState ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo *, - seed, - graphicsPipelineCreateInfo.pTessellationState ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo *, seed, graphicsPipelineCreateInfo.pViewportState ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo *, - seed, - graphicsPipelineCreateInfo.pRasterizationState ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo *, - seed, - graphicsPipelineCreateInfo.pMultisampleState ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo *, - seed, - graphicsPipelineCreateInfo.pDepthStencilState ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo *, - seed, - graphicsPipelineCreateInfo.pColorBlendState ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo *, seed, graphicsPipelineCreateInfo.pDynamicState ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayout, seed, graphicsPipelineCreateInfo.layout ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPass, seed, graphicsPipelineCreateInfo.renderPass ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsPipelineCreateInfo.subpass ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, graphicsPipelineCreateInfo.basePipelineHandle ); - VULKAN_HPP_HASH_COMBINE( int32_t, seed, graphicsPipelineCreateInfo.basePipelineIndex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct GraphicsShaderGroupCreateInfoNV { using NativeType = VkGraphicsShaderGroupCreateInfoNV; @@ -35445,29 +33628,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkGraphicsShaderGroupCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkGraphicsShaderGroupCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkGraphicsShaderGroupCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkGraphicsShaderGroupCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stageCount, pStages, pVertexInputState, pTessellationState ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GraphicsShaderGroupCreateInfoNV const & ) const = default; #else bool operator==( GraphicsShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageCount == rhs.stageCount ) && - ( pStages == rhs.pStages ) && ( pVertexInputState == rhs.pVertexInputState ) && - ( pTessellationState == rhs.pTessellationState ); + return this->reflect() == rhs.reflect(); } bool operator!=( GraphicsShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -35494,33 +33690,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = GraphicsShaderGroupCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV const & graphicsShaderGroupCreateInfoNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, graphicsShaderGroupCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, graphicsShaderGroupCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsShaderGroupCreateInfoNV.stageCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo *, seed, graphicsShaderGroupCreateInfoNV.pStages ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo *, - seed, - graphicsShaderGroupCreateInfoNV.pVertexInputState ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo *, - seed, - graphicsShaderGroupCreateInfoNV.pTessellationState ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct GraphicsPipelineShaderGroupsCreateInfoNV { using NativeType = VkGraphicsPipelineShaderGroupsCreateInfoNV; @@ -35632,28 +33801,42 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkGraphicsPipelineShaderGroupsCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkGraphicsPipelineShaderGroupsCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkGraphicsPipelineShaderGroupsCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkGraphicsPipelineShaderGroupsCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, groupCount, pGroups, pipelineCount, pPipelines ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GraphicsPipelineShaderGroupsCreateInfoNV const & ) const = default; #else bool operator==( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( groupCount == rhs.groupCount ) && - ( pGroups == rhs.pGroups ) && ( pipelineCount == rhs.pipelineCount ) && ( pPipelines == rhs.pPipelines ); + return this->reflect() == rhs.reflect(); } bool operator!=( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -35681,31 +33864,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = GraphicsPipelineShaderGroupsCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV const & - graphicsPipelineShaderGroupsCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, graphicsPipelineShaderGroupsCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, graphicsPipelineShaderGroupsCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsPipelineShaderGroupsCreateInfoNV.groupCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV *, - seed, - graphicsPipelineShaderGroupsCreateInfoNV.pGroups ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, graphicsPipelineShaderGroupsCreateInfoNV.pipelineCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::Pipeline *, seed, graphicsPipelineShaderGroupsCreateInfoNV.pPipelines ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct XYColorEXT { using NativeType = VkXYColorEXT; @@ -35745,27 +33903,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkXYColorEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkXYColorEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkXYColorEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkXYColorEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( XYColorEXT const & ) const = default; #else bool operator==( XYColorEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( x == rhs.x ) && ( y == rhs.y ); + return this->reflect() == rhs.reflect(); } bool operator!=( XYColorEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -35780,22 +33948,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "XYColorEXT is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::XYColorEXT const & xYColorEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( float, seed, xYColorEXT.x ); - VULKAN_HPP_HASH_COMBINE( float, seed, xYColorEXT.y ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct HdrMetadataEXT { using NativeType = VkHdrMetadataEXT; @@ -35898,31 +34050,55 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkHdrMetadataEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkHdrMetadataEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkHdrMetadataEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkHdrMetadataEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + displayPrimaryRed, + displayPrimaryGreen, + displayPrimaryBlue, + whitePoint, + maxLuminance, + minLuminance, + maxContentLightLevel, + maxFrameAverageLightLevel ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( HdrMetadataEXT const & ) const = default; #else bool operator==( HdrMetadataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayPrimaryRed == rhs.displayPrimaryRed ) && - ( displayPrimaryGreen == rhs.displayPrimaryGreen ) && ( displayPrimaryBlue == rhs.displayPrimaryBlue ) && - ( whitePoint == rhs.whitePoint ) && ( maxLuminance == rhs.maxLuminance ) && - ( minLuminance == rhs.minLuminance ) && ( maxContentLightLevel == rhs.maxContentLightLevel ) && - ( maxFrameAverageLightLevel == rhs.maxFrameAverageLightLevel ); + return this->reflect() == rhs.reflect(); } bool operator!=( HdrMetadataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -35951,30 +34127,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = HdrMetadataEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::HdrMetadataEXT const & hdrMetadataEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, hdrMetadataEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, hdrMetadataEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XYColorEXT, seed, hdrMetadataEXT.displayPrimaryRed ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XYColorEXT, seed, hdrMetadataEXT.displayPrimaryGreen ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XYColorEXT, seed, hdrMetadataEXT.displayPrimaryBlue ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XYColorEXT, seed, hdrMetadataEXT.whitePoint ); - VULKAN_HPP_HASH_COMBINE( float, seed, hdrMetadataEXT.maxLuminance ); - VULKAN_HPP_HASH_COMBINE( float, seed, hdrMetadataEXT.minLuminance ); - VULKAN_HPP_HASH_COMBINE( float, seed, hdrMetadataEXT.maxContentLightLevel ); - VULKAN_HPP_HASH_COMBINE( float, seed, hdrMetadataEXT.maxFrameAverageLightLevel ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct HeadlessSurfaceCreateInfoEXT { using NativeType = VkHeadlessSurfaceCreateInfoEXT; @@ -36018,27 +34170,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkHeadlessSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkHeadlessSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkHeadlessSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkHeadlessSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( HeadlessSurfaceCreateInfoEXT const & ) const = default; #else bool operator==( HeadlessSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( HeadlessSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -36062,25 +34226,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = HeadlessSurfaceCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( - VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & headlessSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, headlessSurfaceCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, headlessSurfaceCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagsEXT, seed, headlessSurfaceCreateInfoEXT.flags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_IOS_MVK ) struct IOSSurfaceCreateInfoMVK { @@ -36132,27 +34277,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkIOSSurfaceCreateInfoMVK const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkIOSSurfaceCreateInfoMVK const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkIOSSurfaceCreateInfoMVK &() VULKAN_HPP_NOEXCEPT + explicit operator VkIOSSurfaceCreateInfoMVK &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pView ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( IOSSurfaceCreateInfoMVK const & ) const = default; # else bool operator==( IOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pView == rhs.pView ); + return this->reflect() == rhs.reflect(); } bool operator!=( IOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -36175,26 +34333,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = IOSSurfaceCreateInfoMVK; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & iOSSurfaceCreateInfoMVK ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, iOSSurfaceCreateInfoMVK.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, iOSSurfaceCreateInfoMVK.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateFlagsMVK, seed, iOSSurfaceCreateInfoMVK.flags ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, iOSSurfaceCreateInfoMVK.pView ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_IOS_MVK*/ struct ImageBlit @@ -36257,28 +34395,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageBlit const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageBlit const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageBlit &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageBlit &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcSubresource, srcOffsets, dstSubresource, dstOffsets ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageBlit const & ) const = default; #else bool operator==( ImageBlit const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( srcSubresource == rhs.srcSubresource ) && ( srcOffsets == rhs.srcOffsets ) && - ( dstSubresource == rhs.dstSubresource ) && ( dstOffsets == rhs.dstOffsets ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageBlit const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -36295,30 +34445,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageBlit is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit const & imageBlit ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageBlit.srcSubresource ); - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageBlit.srcOffsets[i] ); - } - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageBlit.dstSubresource ); - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageBlit.dstOffsets[i] ); - } - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_FUCHSIA ) struct ImageFormatConstraintsInfoFUCHSIA { @@ -36411,30 +34537,51 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageFormatConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageFormatConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageFormatConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageFormatConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + imageCreateInfo, + requiredFormatFeatures, + flags, + sysmemPixelFormat, + colorSpaceCount, + pColorSpaces ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageFormatConstraintsInfoFUCHSIA const & ) const = default; # else bool operator==( ImageFormatConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageCreateInfo == rhs.imageCreateInfo ) && - ( requiredFormatFeatures == rhs.requiredFormatFeatures ) && ( flags == rhs.flags ) && - ( sysmemPixelFormat == rhs.sysmemPixelFormat ) && ( colorSpaceCount == rhs.colorSpaceCount ) && - ( pColorSpaces == rhs.pColorSpaces ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageFormatConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -36462,34 +34609,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = ImageFormatConstraintsInfoFUCHSIA; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA const & - imageFormatConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageFormatConstraintsInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageFormatConstraintsInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ImageCreateInfo, seed, imageFormatConstraintsInfoFUCHSIA.imageCreateInfo ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::FormatFeatureFlags, seed, imageFormatConstraintsInfoFUCHSIA.requiredFormatFeatures ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ImageFormatConstraintsFlagsFUCHSIA, seed, imageFormatConstraintsInfoFUCHSIA.flags ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, imageFormatConstraintsInfoFUCHSIA.sysmemPixelFormat ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageFormatConstraintsInfoFUCHSIA.colorSpaceCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA *, seed, imageFormatConstraintsInfoFUCHSIA.pColorSpaces ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_FUCHSIA*/ #if defined( VK_USE_PLATFORM_FUCHSIA ) @@ -36589,30 +34708,42 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, formatConstraintsCount, pFormatConstraints, bufferCollectionConstraints, flags ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageConstraintsInfoFUCHSIA const & ) const = default; # else bool operator==( ImageConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( formatConstraintsCount == rhs.formatConstraintsCount ) && - ( pFormatConstraints == rhs.pFormatConstraints ) && - ( bufferCollectionConstraints == rhs.bufferCollectionConstraints ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -36638,33 +34769,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = ImageConstraintsInfoFUCHSIA; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA const & imageConstraintsInfoFUCHSIA ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageConstraintsInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageConstraintsInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageConstraintsInfoFUCHSIA.formatConstraintsCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA *, - seed, - imageConstraintsInfoFUCHSIA.pFormatConstraints ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA, - seed, - imageConstraintsInfoFUCHSIA.bufferCollectionConstraints ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFlagsFUCHSIA, seed, imageConstraintsInfoFUCHSIA.flags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_FUCHSIA*/ struct ImageCopy @@ -36734,28 +34838,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageCopy const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageCopy const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageCopy &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageCopy &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageCopy const & ) const = default; #else bool operator==( ImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) && - ( dstSubresource == rhs.dstSubresource ) && ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -36773,25 +34890,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageCopy is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy const & imageCopy ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageCopy.srcSubresource ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageCopy.srcOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageCopy.dstSubresource ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageCopy.dstOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageCopy.extent ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SubresourceLayout { using NativeType = VkSubresourceLayout; @@ -36824,28 +34922,41 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkSubresourceLayout const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSubresourceLayout const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSubresourceLayout &() VULKAN_HPP_NOEXCEPT + explicit operator VkSubresourceLayout &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( offset, size, rowPitch, arrayPitch, depthPitch ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubresourceLayout const & ) const = default; #else bool operator==( SubresourceLayout const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( offset == rhs.offset ) && ( size == rhs.size ) && ( rowPitch == rhs.rowPitch ) && - ( arrayPitch == rhs.arrayPitch ) && ( depthPitch == rhs.depthPitch ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubresourceLayout const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -36863,25 +34974,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SubresourceLayout is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout const & subresourceLayout ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.offset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.size ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.rowPitch ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.arrayPitch ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, subresourceLayout.depthPitch ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageDrmFormatModifierExplicitCreateInfoEXT { using NativeType = VkImageDrmFormatModifierExplicitCreateInfoEXT; @@ -36972,29 +35064,41 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageDrmFormatModifierExplicitCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageDrmFormatModifierExplicitCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageDrmFormatModifierExplicitCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageDrmFormatModifierExplicitCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, drmFormatModifier, drmFormatModifierPlaneCount, pPlaneLayouts ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageDrmFormatModifierExplicitCreateInfoEXT const & ) const = default; #else bool operator==( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ) && - ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) && - ( pPlaneLayouts == rhs.pPlaneLayouts ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -37021,29 +35125,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImageDrmFormatModifierExplicitCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT const & - imageDrmFormatModifierExplicitCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, imageDrmFormatModifierExplicitCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageDrmFormatModifierExplicitCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifier ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifierPlaneCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SubresourceLayout *, - seed, - imageDrmFormatModifierExplicitCreateInfoEXT.pPlaneLayouts ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageDrmFormatModifierListCreateInfoEXT { using NativeType = VkImageDrmFormatModifierListCreateInfoEXT; @@ -37120,29 +35201,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageDrmFormatModifierListCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageDrmFormatModifierListCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageDrmFormatModifierListCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageDrmFormatModifierListCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifiers ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageDrmFormatModifierListCreateInfoEXT const & ) const = default; #else bool operator==( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( drmFormatModifierCount == rhs.drmFormatModifierCount ) && - ( pDrmFormatModifiers == rhs.pDrmFormatModifiers ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -37168,25 +35260,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImageDrmFormatModifierListCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT const & - imageDrmFormatModifierListCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageDrmFormatModifierListCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageDrmFormatModifierListCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageDrmFormatModifierListCreateInfoEXT.drmFormatModifierCount ); - VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, imageDrmFormatModifierListCreateInfoEXT.pDrmFormatModifiers ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageDrmFormatModifierPropertiesEXT { using NativeType = VkImageDrmFormatModifierPropertiesEXT; @@ -37218,27 +35291,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkImageDrmFormatModifierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageDrmFormatModifierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageDrmFormatModifierPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageDrmFormatModifierPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, drmFormatModifier ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageDrmFormatModifierPropertiesEXT const & ) const = default; #else bool operator==( ImageDrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageDrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -37262,24 +35345,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImageDrmFormatModifierPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT const & - imageDrmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageDrmFormatModifierPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, imageDrmFormatModifierPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, imageDrmFormatModifierPropertiesEXT.drmFormatModifier ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageFormatListCreateInfo { using NativeType = VkImageFormatListCreateInfo; @@ -37351,28 +35416,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageFormatListCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageFormatListCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageFormatListCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageFormatListCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, viewFormatCount, pViewFormats ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageFormatListCreateInfo const & ) const = default; #else bool operator==( ImageFormatListCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewFormatCount == rhs.viewFormatCount ) && - ( pViewFormats == rhs.pViewFormats ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageFormatListCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -37397,25 +35474,6 @@ namespace VULKAN_HPP_NAMESPACE }; using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo const & imageFormatListCreateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageFormatListCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageFormatListCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageFormatListCreateInfo.viewFormatCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Format *, seed, imageFormatListCreateInfo.pViewFormats ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageFormatProperties2 { using NativeType = VkImageFormatProperties2; @@ -37444,27 +35502,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkImageFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageFormatProperties2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageFormatProperties2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageFormatProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageFormatProperties2 const & ) const = default; #else bool operator==( ImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageFormatProperties == rhs.imageFormatProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -37488,25 +35558,6 @@ namespace VULKAN_HPP_NAMESPACE }; using ImageFormatProperties2KHR = ImageFormatProperties2; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties2 const & imageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageFormatProperties2.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, imageFormatProperties2.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ImageFormatProperties, seed, imageFormatProperties2.imageFormatProperties ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageMemoryBarrier { using NativeType = VkImageMemoryBarrier; @@ -37612,31 +35663,55 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageMemoryBarrier &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageMemoryBarrier &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + srcAccessMask, + dstAccessMask, + oldLayout, + newLayout, + srcQueueFamilyIndex, + dstQueueFamilyIndex, + image, + subresourceRange ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageMemoryBarrier const & ) const = default; #else bool operator==( ImageMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) && - ( dstAccessMask == rhs.dstAccessMask ) && ( oldLayout == rhs.oldLayout ) && - ( newLayout == rhs.newLayout ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && - ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( image == rhs.image ) && - ( subresourceRange == rhs.subresourceRange ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -37665,31 +35740,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImageMemoryBarrier; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier const & imageMemoryBarrier ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageMemoryBarrier.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageMemoryBarrier.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, imageMemoryBarrier.srcAccessMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, imageMemoryBarrier.dstAccessMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageMemoryBarrier.oldLayout ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, imageMemoryBarrier.newLayout ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageMemoryBarrier.srcQueueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, imageMemoryBarrier.dstQueueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageMemoryBarrier.image ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceRange, seed, imageMemoryBarrier.subresourceRange ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageMemoryRequirementsInfo2 { using NativeType = VkImageMemoryRequirementsInfo2; @@ -37733,27 +35783,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageMemoryRequirementsInfo2 const & ) const = default; #else bool operator==( ImageMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -37778,24 +35838,6 @@ namespace VULKAN_HPP_NAMESPACE }; using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( - VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 const & imageMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageMemoryRequirementsInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageMemoryRequirementsInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageMemoryRequirementsInfo2.image ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_FUCHSIA ) struct ImagePipeSurfaceCreateInfoFUCHSIA { @@ -37852,28 +35894,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImagePipeSurfaceCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImagePipeSurfaceCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImagePipeSurfaceCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + explicit operator VkImagePipeSurfaceCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, imagePipeHandle ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImagePipeSurfaceCreateInfoFUCHSIA const & ) const = default; # else bool operator==( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( memcmp( &imagePipeHandle, &rhs.imagePipeHandle, sizeof( zx_handle_t ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -37897,27 +35951,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = ImagePipeSurfaceCreateInfoFUCHSIA; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & - imagePipeSurfaceCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imagePipeSurfaceCreateInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imagePipeSurfaceCreateInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateFlagsFUCHSIA, seed, imagePipeSurfaceCreateInfoFUCHSIA.flags ); - VULKAN_HPP_HASH_COMBINE( zx_handle_t, seed, imagePipeSurfaceCreateInfoFUCHSIA.imagePipeHandle ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_FUCHSIA*/ struct ImagePlaneMemoryRequirementsInfo @@ -37966,27 +35999,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImagePlaneMemoryRequirementsInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImagePlaneMemoryRequirementsInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImagePlaneMemoryRequirementsInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkImagePlaneMemoryRequirementsInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, planeAspect ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImagePlaneMemoryRequirementsInfo const & ) const = default; #else bool operator==( ImagePlaneMemoryRequirementsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImagePlaneMemoryRequirementsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38011,26 +36056,6 @@ namespace VULKAN_HPP_NAMESPACE }; using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo const & imagePlaneMemoryRequirementsInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imagePlaneMemoryRequirementsInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imagePlaneMemoryRequirementsInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ImageAspectFlagBits, seed, imagePlaneMemoryRequirementsInfo.planeAspect ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageResolve { using NativeType = VkImageResolve; @@ -38100,28 +36125,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageResolve const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageResolve const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageResolve &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageResolve &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageResolve const & ) const = default; #else bool operator==( ImageResolve const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) && - ( dstSubresource == rhs.dstSubresource ) && ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageResolve const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38139,25 +36177,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageResolve is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve const & imageResolve ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageResolve.srcSubresource ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageResolve.srcOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageResolve.dstSubresource ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageResolve.dstOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageResolve.extent ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageResolve2KHR { using NativeType = VkImageResolve2KHR; @@ -38236,29 +36255,43 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageResolve2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageResolve2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageResolve2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageResolve2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageResolve2KHR const & ) const = default; #else bool operator==( ImageResolve2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && - ( srcOffset == rhs.srcOffset ) && ( dstSubresource == rhs.dstSubresource ) && - ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageResolve2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38284,27 +36317,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImageResolve2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve2KHR const & imageResolve2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageResolve2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageResolve2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageResolve2KHR.srcSubresource ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageResolve2KHR.srcOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers, seed, imageResolve2KHR.dstSubresource ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset3D, seed, imageResolve2KHR.dstOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, imageResolve2KHR.extent ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageSparseMemoryRequirementsInfo2 { using NativeType = VkImageSparseMemoryRequirementsInfo2; @@ -38352,27 +36364,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageSparseMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageSparseMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageSparseMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageSparseMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageSparseMemoryRequirementsInfo2 const & ) const = default; #else bool operator==( ImageSparseMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageSparseMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38397,24 +36419,6 @@ namespace VULKAN_HPP_NAMESPACE }; using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 const & - imageSparseMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageSparseMemoryRequirementsInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageSparseMemoryRequirementsInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageSparseMemoryRequirementsInfo2.image ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageStencilUsageCreateInfo { using NativeType = VkImageStencilUsageCreateInfo; @@ -38459,27 +36463,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageStencilUsageCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageStencilUsageCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageStencilUsageCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageStencilUsageCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stencilUsage ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageStencilUsageCreateInfo const & ) const = default; #else bool operator==( ImageStencilUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilUsage == rhs.stencilUsage ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageStencilUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38504,24 +36520,6 @@ namespace VULKAN_HPP_NAMESPACE }; using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo const & imageStencilUsageCreateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageStencilUsageCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageStencilUsageCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, imageStencilUsageCreateInfo.stencilUsage ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageSwapchainCreateInfoKHR { using NativeType = VkImageSwapchainCreateInfoKHR; @@ -38566,27 +36564,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchain ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageSwapchainCreateInfoKHR const & ) const = default; #else bool operator==( ImageSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38610,24 +36620,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImageSwapchainCreateInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR const & imageSwapchainCreateInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageSwapchainCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageSwapchainCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainKHR, seed, imageSwapchainCreateInfoKHR.swapchain ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageViewASTCDecodeModeEXT { using NativeType = VkImageViewASTCDecodeModeEXT; @@ -38672,27 +36664,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageViewASTCDecodeModeEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageViewASTCDecodeModeEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageViewASTCDecodeModeEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageViewASTCDecodeModeEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, decodeMode ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageViewASTCDecodeModeEXT const & ) const = default; #else bool operator==( ImageViewASTCDecodeModeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( decodeMode == rhs.decodeMode ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageViewASTCDecodeModeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38715,24 +36717,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImageViewASTCDecodeModeEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT const & imageViewASTCDecodeModeEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewASTCDecodeModeEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewASTCDecodeModeEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, imageViewASTCDecodeModeEXT.decodeMode ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageViewAddressPropertiesNVX { using NativeType = VkImageViewAddressPropertiesNVX; @@ -38765,28 +36749,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkImageViewAddressPropertiesNVX const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageViewAddressPropertiesNVX const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageViewAddressPropertiesNVX &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageViewAddressPropertiesNVX &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceAddress, size ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageViewAddressPropertiesNVX const & ) const = default; #else bool operator==( ImageViewAddressPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress ) && - ( size == rhs.size ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageViewAddressPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38811,25 +36807,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImageViewAddressPropertiesNVX; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX const & imageViewAddressPropertiesNVX ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewAddressPropertiesNVX.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, imageViewAddressPropertiesNVX.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceAddress, seed, imageViewAddressPropertiesNVX.deviceAddress ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, imageViewAddressPropertiesNVX.size ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageViewCreateInfo { using NativeType = VkImageViewCreateInfo; @@ -38916,29 +36893,44 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageViewCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageViewCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, image, viewType, format, components, subresourceRange ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageViewCreateInfo const & ) const = default; #else bool operator==( ImageViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( image == rhs.image ) && - ( viewType == rhs.viewType ) && ( format == rhs.format ) && ( components == rhs.components ) && - ( subresourceRange == rhs.subresourceRange ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38965,29 +36957,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImageViewCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & imageViewCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageViewCreateFlags, seed, imageViewCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, imageViewCreateInfo.image ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageViewType, seed, imageViewCreateInfo.viewType ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, imageViewCreateInfo.format ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ComponentMapping, seed, imageViewCreateInfo.components ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageSubresourceRange, seed, imageViewCreateInfo.subresourceRange ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageViewHandleInfoNVX { using NativeType = VkImageViewHandleInfoNVX; @@ -39049,28 +37018,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageViewHandleInfoNVX const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageViewHandleInfoNVX const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageViewHandleInfoNVX &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageViewHandleInfoNVX &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageView, descriptorType, sampler ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageViewHandleInfoNVX const & ) const = default; #else bool operator==( ImageViewHandleInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) && - ( descriptorType == rhs.descriptorType ) && ( sampler == rhs.sampler ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageViewHandleInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -39095,26 +37077,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImageViewHandleInfoNVX; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX const & imageViewHandleInfoNVX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewHandleInfoNVX.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewHandleInfoNVX.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageView, seed, imageViewHandleInfoNVX.imageView ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, imageViewHandleInfoNVX.descriptorType ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Sampler, seed, imageViewHandleInfoNVX.sampler ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageViewMinLodCreateInfoEXT { using NativeType = VkImageViewMinLodCreateInfoEXT; @@ -39155,27 +37117,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageViewMinLodCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageViewMinLodCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageViewMinLodCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageViewMinLodCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minLod ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageViewMinLodCreateInfoEXT const & ) const = default; #else bool operator==( ImageViewMinLodCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minLod == rhs.minLod ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageViewMinLodCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -39199,24 +37171,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImageViewMinLodCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( - VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT const & imageViewMinLodCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewMinLodCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewMinLodCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( float, seed, imageViewMinLodCreateInfoEXT.minLod ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImageViewUsageCreateInfo { using NativeType = VkImageViewUsageCreateInfo; @@ -39260,27 +37214,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImageViewUsageCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImageViewUsageCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImageViewUsageCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkImageViewUsageCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, usage ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageViewUsageCreateInfo const & ) const = default; #else bool operator==( ImageViewUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usage == rhs.usage ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageViewUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -39304,24 +37270,6 @@ namespace VULKAN_HPP_NAMESPACE }; using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo const & imageViewUsageCreateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, imageViewUsageCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, imageViewUsageCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, imageViewUsageCreateInfo.usage ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_ANDROID_KHR ) struct ImportAndroidHardwareBufferInfoANDROID { @@ -39371,27 +37319,37 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImportAndroidHardwareBufferInfoANDROID const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImportAndroidHardwareBufferInfoANDROID const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImportAndroidHardwareBufferInfoANDROID &() VULKAN_HPP_NOEXCEPT + explicit operator VkImportAndroidHardwareBufferInfoANDROID &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportAndroidHardwareBufferInfoANDROID const & ) const = default; # else bool operator==( ImportAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -39415,25 +37373,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = ImportAndroidHardwareBufferInfoANDROID; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID const & - importAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importAndroidHardwareBufferInfoANDROID.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, importAndroidHardwareBufferInfoANDROID.pNext ); - VULKAN_HPP_HASH_COMBINE( struct AHardwareBuffer *, seed, importAndroidHardwareBufferInfoANDROID.buffer ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ struct ImportFenceFdInfoKHR @@ -39504,28 +37443,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImportFenceFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImportFenceFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImportFenceFdInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkImportFenceFdInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fence, flags, handleType, fd ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportFenceFdInfoKHR const & ) const = default; #else bool operator==( ImportFenceFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( flags == rhs.flags ) && - ( handleType == rhs.handleType ) && ( fd == rhs.fd ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportFenceFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -39551,28 +37504,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImportFenceFdInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR const & importFenceFdInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importFenceFdInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, importFenceFdInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, importFenceFdInfoKHR.fence ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FenceImportFlags, seed, importFenceFdInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, importFenceFdInfoKHR.handleType ); - VULKAN_HPP_HASH_COMBINE( int, seed, importFenceFdInfoKHR.fd ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_WIN32_KHR ) struct ImportFenceWin32HandleInfoKHR { @@ -39654,28 +37585,43 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImportFenceWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImportFenceWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImportFenceWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkImportFenceWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fence, flags, handleType, handle, name ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportFenceWin32HandleInfoKHR const & ) const = default; # else bool operator==( ImportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( flags == rhs.flags ) && - ( handleType == rhs.handleType ) && ( handle == rhs.handle ) && ( name == rhs.name ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -39703,30 +37649,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = ImportFenceWin32HandleInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR const & importFenceWin32HandleInfoKHR ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importFenceWin32HandleInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, importFenceWin32HandleInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Fence, seed, importFenceWin32HandleInfoKHR.fence ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FenceImportFlags, seed, importFenceWin32HandleInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, importFenceWin32HandleInfoKHR.handleType ); - VULKAN_HPP_HASH_COMBINE( HANDLE, seed, importFenceWin32HandleInfoKHR.handle ); - VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, importFenceWin32HandleInfoKHR.name ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #if defined( VK_USE_PLATFORM_FUCHSIA ) @@ -39785,28 +37707,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImportMemoryBufferCollectionFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImportMemoryBufferCollectionFUCHSIA const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImportMemoryBufferCollectionFUCHSIA &() VULKAN_HPP_NOEXCEPT + explicit operator VkImportMemoryBufferCollectionFUCHSIA &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, collection, index ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportMemoryBufferCollectionFUCHSIA const & ) const = default; # else bool operator==( ImportMemoryBufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && - ( index == rhs.index ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportMemoryBufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -39830,27 +37764,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = ImportMemoryBufferCollectionFUCHSIA; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA const & - importMemoryBufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryBufferCollectionFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryBufferCollectionFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, seed, importMemoryBufferCollectionFUCHSIA.collection ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, importMemoryBufferCollectionFUCHSIA.index ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_FUCHSIA*/ struct ImportMemoryFdInfoKHR @@ -39904,27 +37817,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImportMemoryFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImportMemoryFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImportMemoryFdInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkImportMemoryFdInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType, fd ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportMemoryFdInfoKHR const & ) const = default; #else bool operator==( ImportMemoryFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( fd == rhs.fd ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportMemoryFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -39948,26 +37874,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImportMemoryFdInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR const & importMemoryFdInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryFdInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryFdInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, importMemoryFdInfoKHR.handleType ); - VULKAN_HPP_HASH_COMBINE( int, seed, importMemoryFdInfoKHR.fd ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ImportMemoryHostPointerInfoEXT { using NativeType = VkImportMemoryHostPointerInfoEXT; @@ -40022,28 +37928,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImportMemoryHostPointerInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImportMemoryHostPointerInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImportMemoryHostPointerInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkImportMemoryHostPointerInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType, pHostPointer ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportMemoryHostPointerInfoEXT const & ) const = default; #else bool operator==( ImportMemoryHostPointerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && - ( pHostPointer == rhs.pHostPointer ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportMemoryHostPointerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -40069,26 +37987,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImportMemoryHostPointerInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT const & importMemoryHostPointerInfoEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryHostPointerInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryHostPointerInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, importMemoryHostPointerInfoEXT.handleType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, importMemoryHostPointerInfoEXT.pHostPointer ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_WIN32_KHR ) struct ImportMemoryWin32HandleInfoKHR { @@ -40152,28 +38050,41 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImportMemoryWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImportMemoryWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImportMemoryWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkImportMemoryWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType, handle, name ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportMemoryWin32HandleInfoKHR const & ) const = default; # else bool operator==( ImportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && - ( handle == rhs.handle ) && ( name == rhs.name ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -40199,28 +38110,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = ImportMemoryWin32HandleInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR const & importMemoryWin32HandleInfoKHR ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryWin32HandleInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryWin32HandleInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, importMemoryWin32HandleInfoKHR.handleType ); - VULKAN_HPP_HASH_COMBINE( HANDLE, seed, importMemoryWin32HandleInfoKHR.handle ); - VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, importMemoryWin32HandleInfoKHR.name ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #if defined( VK_USE_PLATFORM_WIN32_KHR ) @@ -40277,28 +38166,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImportMemoryWin32HandleInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImportMemoryWin32HandleInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImportMemoryWin32HandleInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkImportMemoryWin32HandleInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType, handle ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportMemoryWin32HandleInfoNV const & ) const = default; # else bool operator==( ImportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && - ( handle == rhs.handle ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -40322,27 +38223,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = ImportMemoryWin32HandleInfoNV; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV const & importMemoryWin32HandleInfoNV ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryWin32HandleInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryWin32HandleInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV, seed, importMemoryWin32HandleInfoNV.handleType ); - VULKAN_HPP_HASH_COMBINE( HANDLE, seed, importMemoryWin32HandleInfoNV.handle ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #if defined( VK_USE_PLATFORM_FUCHSIA ) @@ -40402,28 +38282,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImportMemoryZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImportMemoryZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImportMemoryZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + explicit operator VkImportMemoryZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType, handle ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportMemoryZirconHandleInfoFUCHSIA const & ) const = default; # else bool operator==( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && - ( memcmp( &handle, &rhs.handle, sizeof( zx_handle_t ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -40448,27 +38340,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = ImportMemoryZirconHandleInfoFUCHSIA; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA const & - importMemoryZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importMemoryZirconHandleInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, importMemoryZirconHandleInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, importMemoryZirconHandleInfoFUCHSIA.handleType ); - VULKAN_HPP_HASH_COMBINE( zx_handle_t, seed, importMemoryZirconHandleInfoFUCHSIA.handle ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_FUCHSIA*/ struct ImportSemaphoreFdInfoKHR @@ -40541,28 +38412,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImportSemaphoreFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImportSemaphoreFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImportSemaphoreFdInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkImportSemaphoreFdInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, flags, handleType, fd ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportSemaphoreFdInfoKHR const & ) const = default; #else bool operator==( ImportSemaphoreFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && - ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && ( fd == rhs.fd ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportSemaphoreFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -40589,28 +38474,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ImportSemaphoreFdInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR const & importSemaphoreFdInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importSemaphoreFdInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, importSemaphoreFdInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, importSemaphoreFdInfoKHR.semaphore ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SemaphoreImportFlags, seed, importSemaphoreFdInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, importSemaphoreFdInfoKHR.handleType ); - VULKAN_HPP_HASH_COMBINE( int, seed, importSemaphoreFdInfoKHR.fd ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_WIN32_KHR ) struct ImportSemaphoreWin32HandleInfoKHR { @@ -40693,29 +38556,43 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImportSemaphoreWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImportSemaphoreWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImportSemaphoreWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkImportSemaphoreWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, flags, handleType, handle, name ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportSemaphoreWin32HandleInfoKHR const & ) const = default; # else bool operator==( ImportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && - ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && ( handle == rhs.handle ) && - ( name == rhs.name ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -40743,31 +38620,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = ImportSemaphoreWin32HandleInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR const & - importSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importSemaphoreWin32HandleInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, importSemaphoreWin32HandleInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, importSemaphoreWin32HandleInfoKHR.semaphore ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SemaphoreImportFlags, seed, importSemaphoreWin32HandleInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, importSemaphoreWin32HandleInfoKHR.handleType ); - VULKAN_HPP_HASH_COMBINE( HANDLE, seed, importSemaphoreWin32HandleInfoKHR.handle ); - VULKAN_HPP_HASH_COMBINE( LPCWSTR, seed, importSemaphoreWin32HandleInfoKHR.name ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #if defined( VK_USE_PLATFORM_FUCHSIA ) @@ -40847,29 +38699,42 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkImportSemaphoreZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkImportSemaphoreZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkImportSemaphoreZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + explicit operator VkImportSemaphoreZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, flags, handleType, zirconHandle ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportSemaphoreZirconHandleInfoFUCHSIA const & ) const = default; # else bool operator==( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && - ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && - ( memcmp( &zirconHandle, &rhs.zirconHandle, sizeof( zx_handle_t ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -40897,31 +38762,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = ImportSemaphoreZirconHandleInfoFUCHSIA; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA const & - importSemaphoreZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, importSemaphoreZirconHandleInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, importSemaphoreZirconHandleInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, importSemaphoreZirconHandleInfoFUCHSIA.semaphore ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SemaphoreImportFlags, seed, importSemaphoreZirconHandleInfoFUCHSIA.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, - seed, - importSemaphoreZirconHandleInfoFUCHSIA.handleType ); - VULKAN_HPP_HASH_COMBINE( zx_handle_t, seed, importSemaphoreZirconHandleInfoFUCHSIA.zirconHandle ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_FUCHSIA*/ struct IndirectCommandsLayoutTokenNV @@ -41138,34 +38978,65 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkIndirectCommandsLayoutTokenNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkIndirectCommandsLayoutTokenNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkIndirectCommandsLayoutTokenNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkIndirectCommandsLayoutTokenNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + tokenType, + stream, + offset, + vertexBindingUnit, + vertexDynamicStride, + pushconstantPipelineLayout, + pushconstantShaderStageFlags, + pushconstantOffset, + pushconstantSize, + indirectStateFlags, + indexTypeCount, + pIndexTypes, + pIndexTypeValues ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( IndirectCommandsLayoutTokenNV const & ) const = default; #else bool operator==( IndirectCommandsLayoutTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tokenType == rhs.tokenType ) && - ( stream == rhs.stream ) && ( offset == rhs.offset ) && ( vertexBindingUnit == rhs.vertexBindingUnit ) && - ( vertexDynamicStride == rhs.vertexDynamicStride ) && - ( pushconstantPipelineLayout == rhs.pushconstantPipelineLayout ) && - ( pushconstantShaderStageFlags == rhs.pushconstantShaderStageFlags ) && - ( pushconstantOffset == rhs.pushconstantOffset ) && ( pushconstantSize == rhs.pushconstantSize ) && - ( indirectStateFlags == rhs.indirectStateFlags ) && ( indexTypeCount == rhs.indexTypeCount ) && - ( pIndexTypes == rhs.pIndexTypes ) && ( pIndexTypeValues == rhs.pIndexTypeValues ); + return this->reflect() == rhs.reflect(); } bool operator!=( IndirectCommandsLayoutTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -41202,40 +39073,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = IndirectCommandsLayoutTokenNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV const & indirectCommandsLayoutTokenNV ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, indirectCommandsLayoutTokenNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, indirectCommandsLayoutTokenNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNV, seed, indirectCommandsLayoutTokenNV.tokenType ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.stream ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.offset ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.vertexBindingUnit ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, indirectCommandsLayoutTokenNV.vertexDynamicStride ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineLayout, seed, indirectCommandsLayoutTokenNV.pushconstantPipelineLayout ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, indirectCommandsLayoutTokenNV.pushconstantShaderStageFlags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.pushconstantOffset ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.pushconstantSize ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::IndirectStateFlagsNV, seed, indirectCommandsLayoutTokenNV.indirectStateFlags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutTokenNV.indexTypeCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::IndexType *, seed, indirectCommandsLayoutTokenNV.pIndexTypes ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, indirectCommandsLayoutTokenNV.pIndexTypeValues ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct IndirectCommandsLayoutCreateInfoNV { using NativeType = VkIndirectCommandsLayoutCreateInfoNV; @@ -41365,30 +39202,44 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkIndirectCommandsLayoutCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkIndirectCommandsLayoutCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkIndirectCommandsLayoutCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkIndirectCommandsLayoutCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pipelineBindPoint, tokenCount, pTokens, streamCount, pStreamStrides ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( IndirectCommandsLayoutCreateInfoNV const & ) const = default; #else bool operator==( IndirectCommandsLayoutCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( tokenCount == rhs.tokenCount ) && - ( pTokens == rhs.pTokens ) && ( streamCount == rhs.streamCount ) && - ( pStreamStrides == rhs.pStreamStrides ); + return this->reflect() == rhs.reflect(); } bool operator!=( IndirectCommandsLayoutCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -41417,32 +39268,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = IndirectCommandsLayoutCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & - indirectCommandsLayoutCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, indirectCommandsLayoutCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, indirectCommandsLayoutCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagsNV, seed, indirectCommandsLayoutCreateInfoNV.flags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, indirectCommandsLayoutCreateInfoNV.pipelineBindPoint ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutCreateInfoNV.tokenCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV *, seed, indirectCommandsLayoutCreateInfoNV.pTokens ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, indirectCommandsLayoutCreateInfoNV.streamCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, indirectCommandsLayoutCreateInfoNV.pStreamStrides ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct InitializePerformanceApiInfoINTEL { using NativeType = VkInitializePerformanceApiInfoINTEL; @@ -41487,27 +39312,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkInitializePerformanceApiInfoINTEL const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkInitializePerformanceApiInfoINTEL const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkInitializePerformanceApiInfoINTEL &() VULKAN_HPP_NOEXCEPT + explicit operator VkInitializePerformanceApiInfoINTEL &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pUserData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( InitializePerformanceApiInfoINTEL const & ) const = default; #else bool operator==( InitializePerformanceApiInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pUserData == rhs.pUserData ); + return this->reflect() == rhs.reflect(); } bool operator!=( InitializePerformanceApiInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -41531,24 +39366,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = InitializePerformanceApiInfoINTEL; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL const & - initializePerformanceApiInfoINTEL ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, initializePerformanceApiInfoINTEL.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, initializePerformanceApiInfoINTEL.pNext ); - VULKAN_HPP_HASH_COMBINE( void *, seed, initializePerformanceApiInfoINTEL.pUserData ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct InputAttachmentAspectReference { using NativeType = VkInputAttachmentAspectReference; @@ -41602,28 +39419,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkInputAttachmentAspectReference const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkInputAttachmentAspectReference const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkInputAttachmentAspectReference &() VULKAN_HPP_NOEXCEPT + explicit operator VkInputAttachmentAspectReference &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( subpass, inputAttachmentIndex, aspectMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( InputAttachmentAspectReference const & ) const = default; #else bool operator==( InputAttachmentAspectReference const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( subpass == rhs.subpass ) && ( inputAttachmentIndex == rhs.inputAttachmentIndex ) && - ( aspectMask == rhs.aspectMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( InputAttachmentAspectReference const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -41642,24 +39468,6 @@ namespace VULKAN_HPP_NAMESPACE "InputAttachmentAspectReference is not nothrow_move_constructible!" ); using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference const & inputAttachmentAspectReference ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, inputAttachmentAspectReference.subpass ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, inputAttachmentAspectReference.inputAttachmentIndex ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, inputAttachmentAspectReference.aspectMask ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct InstanceCreateInfo { using NativeType = VkInstanceCreateInfo; @@ -41783,31 +39591,51 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkInstanceCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkInstanceCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkInstanceCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkInstanceCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + pApplicationInfo, + enabledLayerCount, + ppEnabledLayerNames, + enabledExtensionCount, + ppEnabledExtensionNames ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( InstanceCreateInfo const & ) const = default; #else bool operator==( InstanceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( pApplicationInfo == rhs.pApplicationInfo ) && ( enabledLayerCount == rhs.enabledLayerCount ) && - ( ppEnabledLayerNames == rhs.ppEnabledLayerNames ) && - ( enabledExtensionCount == rhs.enabledExtensionCount ) && - ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames ); + return this->reflect() == rhs.reflect(); } bool operator!=( InstanceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -41834,29 +39662,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = InstanceCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & instanceCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, instanceCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, instanceCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::InstanceCreateFlags, seed, instanceCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ApplicationInfo *, seed, instanceCreateInfo.pApplicationInfo ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, instanceCreateInfo.enabledLayerCount ); - VULKAN_HPP_HASH_COMBINE( const char * const *, seed, instanceCreateInfo.ppEnabledLayerNames ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, instanceCreateInfo.enabledExtensionCount ); - VULKAN_HPP_HASH_COMBINE( const char * const *, seed, instanceCreateInfo.ppEnabledExtensionNames ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct LayerProperties { using NativeType = VkLayerProperties; @@ -41888,28 +39693,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkLayerProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkLayerProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkLayerProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkLayerProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + uint32_t const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( layerName, specVersion, implementationVersion, description ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( LayerProperties const & ) const = default; #else bool operator==( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( layerName == rhs.layerName ) && ( specVersion == rhs.specVersion ) && - ( implementationVersion == rhs.implementationVersion ) && ( description == rhs.description ); + return this->reflect() == rhs.reflect(); } bool operator!=( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -41926,30 +39743,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "LayerProperties is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerProperties const & layerProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, layerProperties.layerName[i] ); - } - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, layerProperties.specVersion ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, layerProperties.implementationVersion ); - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, layerProperties.description[i] ); - } - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_MACOS_MVK ) struct MacOSSurfaceCreateInfoMVK { @@ -42002,27 +39795,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMacOSSurfaceCreateInfoMVK const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMacOSSurfaceCreateInfoMVK const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMacOSSurfaceCreateInfoMVK &() VULKAN_HPP_NOEXCEPT + explicit operator VkMacOSSurfaceCreateInfoMVK &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pView ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MacOSSurfaceCreateInfoMVK const & ) const = default; # else bool operator==( MacOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pView == rhs.pView ); + return this->reflect() == rhs.reflect(); } bool operator!=( MacOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -42045,26 +39851,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = MacOSSurfaceCreateInfoMVK; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & macOSSurfaceCreateInfoMVK ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, macOSSurfaceCreateInfoMVK.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, macOSSurfaceCreateInfoMVK.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateFlagsMVK, seed, macOSSurfaceCreateInfoMVK.flags ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, macOSSurfaceCreateInfoMVK.pView ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_MACOS_MVK*/ struct MappedMemoryRange @@ -42126,28 +39912,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMappedMemoryRange const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMappedMemoryRange const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMappedMemoryRange &() VULKAN_HPP_NOEXCEPT + explicit operator VkMappedMemoryRange &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory, offset, size ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MappedMemoryRange const & ) const = default; #else bool operator==( MappedMemoryRange const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( offset == rhs.offset ) && - ( size == rhs.size ); + return this->reflect() == rhs.reflect(); } bool operator!=( MappedMemoryRange const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -42171,25 +39970,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = MappedMemoryRange; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MappedMemoryRange const & mappedMemoryRange ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, mappedMemoryRange.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, mappedMemoryRange.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, mappedMemoryRange.memory ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, mappedMemoryRange.offset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, mappedMemoryRange.size ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MemoryAllocateFlagsInfo { using NativeType = VkMemoryAllocateFlagsInfo; @@ -42240,28 +40020,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMemoryAllocateFlagsInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryAllocateFlagsInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryAllocateFlagsInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryAllocateFlagsInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, deviceMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryAllocateFlagsInfo const & ) const = default; #else bool operator==( MemoryAllocateFlagsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( deviceMask == rhs.deviceMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryAllocateFlagsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -42286,25 +40078,6 @@ namespace VULKAN_HPP_NAMESPACE }; using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo const & memoryAllocateFlagsInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryAllocateFlagsInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryAllocateFlagsInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryAllocateFlags, seed, memoryAllocateFlagsInfo.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryAllocateFlagsInfo.deviceMask ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MemoryAllocateInfo { using NativeType = VkMemoryAllocateInfo; @@ -42355,28 +40128,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMemoryAllocateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryAllocateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryAllocateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryAllocateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, allocationSize, memoryTypeIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryAllocateInfo const & ) const = default; #else bool operator==( MemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) && - ( memoryTypeIndex == rhs.memoryTypeIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -42399,25 +40184,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = MemoryAllocateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & memoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryAllocateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryAllocateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, memoryAllocateInfo.allocationSize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryAllocateInfo.memoryTypeIndex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MemoryBarrier { using NativeType = VkMemoryBarrier; @@ -42469,28 +40235,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryBarrier &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryBarrier &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcAccessMask, dstAccessMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryBarrier const & ) const = default; #else bool operator==( MemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) && - ( dstAccessMask == rhs.dstAccessMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -42513,24 +40291,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = MemoryBarrier; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier const & memoryBarrier ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryBarrier.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryBarrier.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, memoryBarrier.srcAccessMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, memoryBarrier.dstAccessMask ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MemoryDedicatedAllocateInfo { using NativeType = VkMemoryDedicatedAllocateInfo; @@ -42583,27 +40343,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMemoryDedicatedAllocateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryDedicatedAllocateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryDedicatedAllocateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryDedicatedAllocateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image, buffer ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryDedicatedAllocateInfo const & ) const = default; #else bool operator==( MemoryDedicatedAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryDedicatedAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -42629,25 +40402,6 @@ namespace VULKAN_HPP_NAMESPACE }; using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo const & memoryDedicatedAllocateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryDedicatedAllocateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryDedicatedAllocateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, memoryDedicatedAllocateInfo.image ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, memoryDedicatedAllocateInfo.buffer ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MemoryDedicatedRequirements { using NativeType = VkMemoryDedicatedRequirements; @@ -42679,29 +40433,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkMemoryDedicatedRequirements const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryDedicatedRequirements const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryDedicatedRequirements &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryDedicatedRequirements &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, prefersDedicatedAllocation, requiresDedicatedAllocation ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryDedicatedRequirements const & ) const = default; #else bool operator==( MemoryDedicatedRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( prefersDedicatedAllocation == rhs.prefersDedicatedAllocation ) && - ( requiresDedicatedAllocation == rhs.requiresDedicatedAllocation ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryDedicatedRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -42727,27 +40492,6 @@ namespace VULKAN_HPP_NAMESPACE }; using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements const & memoryDedicatedRequirements ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryDedicatedRequirements.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, memoryDedicatedRequirements.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, memoryDedicatedRequirements.prefersDedicatedAllocation ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, memoryDedicatedRequirements.requiresDedicatedAllocation ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MemoryFdPropertiesKHR { using NativeType = VkMemoryFdPropertiesKHR; @@ -42775,27 +40519,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkMemoryFdPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryFdPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryFdPropertiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryFdPropertiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryTypeBits ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryFdPropertiesKHR const & ) const = default; #else bool operator==( MemoryFdPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryFdPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -42817,24 +40571,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = MemoryFdPropertiesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR const & memoryFdPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryFdPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, memoryFdPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryFdPropertiesKHR.memoryTypeBits ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_ANDROID_KHR ) struct MemoryGetAndroidHardwareBufferInfoANDROID { @@ -42886,27 +40622,39 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMemoryGetAndroidHardwareBufferInfoANDROID const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryGetAndroidHardwareBufferInfoANDROID const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryGetAndroidHardwareBufferInfoANDROID &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryGetAndroidHardwareBufferInfoANDROID &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryGetAndroidHardwareBufferInfoANDROID const & ) const = default; # else bool operator==( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -42930,27 +40678,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = MemoryGetAndroidHardwareBufferInfoANDROID; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID const & - memoryGetAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetAndroidHardwareBufferInfoANDROID.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetAndroidHardwareBufferInfoANDROID.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetAndroidHardwareBufferInfoANDROID.memory ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ struct MemoryGetFdInfoKHR @@ -43006,28 +40733,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMemoryGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory, handleType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryGetFdInfoKHR const & ) const = default; #else bool operator==( MemoryGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -43051,26 +40790,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = MemoryGetFdInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR const & memoryGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetFdInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetFdInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetFdInfoKHR.memory ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, memoryGetFdInfoKHR.handleType ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MemoryGetRemoteAddressInfoNV { using NativeType = VkMemoryGetRemoteAddressInfoNV; @@ -43125,28 +40844,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMemoryGetRemoteAddressInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryGetRemoteAddressInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryGetRemoteAddressInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryGetRemoteAddressInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory, handleType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryGetRemoteAddressInfoNV const & ) const = default; #else bool operator==( MemoryGetRemoteAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryGetRemoteAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -43172,26 +40903,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = MemoryGetRemoteAddressInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( - VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV const & memoryGetRemoteAddressInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetRemoteAddressInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetRemoteAddressInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetRemoteAddressInfoNV.memory ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, memoryGetRemoteAddressInfoNV.handleType ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_WIN32_KHR ) struct MemoryGetWin32HandleInfoKHR { @@ -43247,28 +40958,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMemoryGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory, handleType ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryGetWin32HandleInfoKHR const & ) const = default; # else bool operator==( MemoryGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -43293,27 +41016,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = MemoryGetWin32HandleInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR const & memoryGetWin32HandleInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetWin32HandleInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetWin32HandleInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetWin32HandleInfoKHR.memory ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, memoryGetWin32HandleInfoKHR.handleType ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #if defined( VK_USE_PLATFORM_FUCHSIA ) @@ -43372,28 +41074,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMemoryGetZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryGetZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryGetZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryGetZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory, handleType ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryGetZirconHandleInfoFUCHSIA const & ) const = default; # else bool operator==( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -43418,28 +41132,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = MemoryGetZirconHandleInfoFUCHSIA; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA const & memoryGetZirconHandleInfoFUCHSIA ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryGetZirconHandleInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryGetZirconHandleInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, memoryGetZirconHandleInfoFUCHSIA.memory ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, memoryGetZirconHandleInfoFUCHSIA.handleType ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_FUCHSIA*/ struct MemoryHeap @@ -43468,27 +41160,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkMemoryHeap const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryHeap const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryHeap &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryHeap &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( size, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryHeap const & ) const = default; #else bool operator==( MemoryHeap const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( size == rhs.size ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryHeap const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -43503,22 +41205,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "MemoryHeap is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHeap const & memoryHeap ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, memoryHeap.size ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryHeapFlags, seed, memoryHeap.flags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MemoryHostPointerPropertiesEXT { using NativeType = VkMemoryHostPointerPropertiesEXT; @@ -43548,27 +41234,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkMemoryHostPointerPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryHostPointerPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryHostPointerPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryHostPointerPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryTypeBits ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryHostPointerPropertiesEXT const & ) const = default; #else bool operator==( MemoryHostPointerPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryHostPointerPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -43592,24 +41288,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = MemoryHostPointerPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT const & memoryHostPointerPropertiesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryHostPointerPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, memoryHostPointerPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryHostPointerPropertiesEXT.memoryTypeBits ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MemoryOpaqueCaptureAddressAllocateInfo { using NativeType = VkMemoryOpaqueCaptureAddressAllocateInfo; @@ -43658,27 +41336,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMemoryOpaqueCaptureAddressAllocateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryOpaqueCaptureAddressAllocateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryOpaqueCaptureAddressAllocateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryOpaqueCaptureAddressAllocateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, opaqueCaptureAddress ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryOpaqueCaptureAddressAllocateInfo const & ) const = default; #else bool operator==( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -43704,24 +41392,6 @@ namespace VULKAN_HPP_NAMESPACE }; using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo const & - memoryOpaqueCaptureAddressAllocateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryOpaqueCaptureAddressAllocateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryOpaqueCaptureAddressAllocateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, memoryOpaqueCaptureAddressAllocateInfo.opaqueCaptureAddress ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MemoryPriorityAllocateInfoEXT { using NativeType = VkMemoryPriorityAllocateInfoEXT; @@ -43765,27 +41435,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMemoryPriorityAllocateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryPriorityAllocateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryPriorityAllocateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryPriorityAllocateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, priority ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryPriorityAllocateInfoEXT const & ) const = default; #else bool operator==( MemoryPriorityAllocateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priority == rhs.priority ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryPriorityAllocateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -43809,24 +41489,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = MemoryPriorityAllocateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT const & memoryPriorityAllocateInfoEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryPriorityAllocateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, memoryPriorityAllocateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( float, seed, memoryPriorityAllocateInfoEXT.priority ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MemoryRequirements { using NativeType = VkMemoryRequirements; @@ -43855,27 +41517,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryRequirements &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryRequirements &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( size, alignment, memoryTypeBits ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryRequirements const & ) const = default; #else bool operator==( MemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( size == rhs.size ) && ( alignment == rhs.alignment ) && ( memoryTypeBits == rhs.memoryTypeBits ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -43891,24 +41563,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "MemoryRequirements is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements const & memoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, memoryRequirements.size ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, memoryRequirements.alignment ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryRequirements.memoryTypeBits ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MemoryRequirements2 { using NativeType = VkMemoryRequirements2; @@ -43937,27 +41591,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkMemoryRequirements2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryRequirements2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryRequirements2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryRequirements2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryRequirements ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryRequirements2 const & ) const = default; #else bool operator==( MemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryRequirements == rhs.memoryRequirements ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -43980,24 +41646,6 @@ namespace VULKAN_HPP_NAMESPACE }; using MemoryRequirements2KHR = MemoryRequirements2; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements2 const & memoryRequirements2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryRequirements2.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, memoryRequirements2.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryRequirements, seed, memoryRequirements2.memoryRequirements ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MemoryType { using NativeType = VkMemoryType; @@ -44024,27 +41672,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkMemoryType const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryType const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryType &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryType &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( propertyFlags, heapIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryType const & ) const = default; #else bool operator==( MemoryType const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( propertyFlags == rhs.propertyFlags ) && ( heapIndex == rhs.heapIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryType const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -44059,22 +41717,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "MemoryType is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryType const & memoryType ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryPropertyFlags, seed, memoryType.propertyFlags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryType.heapIndex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_WIN32_KHR ) struct MemoryWin32HandlePropertiesKHR { @@ -44105,27 +41747,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkMemoryWin32HandlePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryWin32HandlePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryWin32HandlePropertiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryWin32HandlePropertiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryTypeBits ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryWin32HandlePropertiesKHR const & ) const = default; # else bool operator==( MemoryWin32HandlePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryWin32HandlePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -44148,25 +41800,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = MemoryWin32HandlePropertiesKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR const & memoryWin32HandlePropertiesKHR ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryWin32HandlePropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, memoryWin32HandlePropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryWin32HandlePropertiesKHR.memoryTypeBits ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #if defined( VK_USE_PLATFORM_FUCHSIA ) @@ -44201,27 +41834,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkMemoryZirconHandlePropertiesFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryZirconHandlePropertiesFUCHSIA const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMemoryZirconHandlePropertiesFUCHSIA &() VULKAN_HPP_NOEXCEPT + explicit operator VkMemoryZirconHandlePropertiesFUCHSIA &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryTypeBits ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryZirconHandlePropertiesFUCHSIA const & ) const = default; # else bool operator==( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -44244,25 +41887,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = MemoryZirconHandlePropertiesFUCHSIA; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA const & - memoryZirconHandlePropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, memoryZirconHandlePropertiesFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, memoryZirconHandlePropertiesFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, memoryZirconHandlePropertiesFUCHSIA.memoryTypeBits ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_FUCHSIA*/ #if defined( VK_USE_PLATFORM_METAL_EXT ) @@ -44317,27 +41941,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMetalSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMetalSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMetalSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkMetalSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pLayer ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MetalSurfaceCreateInfoEXT const & ) const = default; # else bool operator==( MetalSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pLayer == rhs.pLayer ); + return this->reflect() == rhs.reflect(); } bool operator!=( MetalSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -44360,26 +41997,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = MetalSurfaceCreateInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & metalSurfaceCreateInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, metalSurfaceCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, metalSurfaceCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateFlagsEXT, seed, metalSurfaceCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( const CAMetalLayer *, seed, metalSurfaceCreateInfoEXT.pLayer ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_METAL_EXT*/ struct MultiDrawIndexedInfoEXT @@ -44430,28 +42047,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMultiDrawIndexedInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMultiDrawIndexedInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMultiDrawIndexedInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkMultiDrawIndexedInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( firstIndex, indexCount, vertexOffset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MultiDrawIndexedInfoEXT const & ) const = default; #else bool operator==( MultiDrawIndexedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( firstIndex == rhs.firstIndex ) && ( indexCount == rhs.indexCount ) && - ( vertexOffset == rhs.vertexOffset ); + return this->reflect() == rhs.reflect(); } bool operator!=( MultiDrawIndexedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -44468,24 +42094,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "MultiDrawIndexedInfoEXT is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT const & multiDrawIndexedInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, multiDrawIndexedInfoEXT.firstIndex ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, multiDrawIndexedInfoEXT.indexCount ); - VULKAN_HPP_HASH_COMBINE( int32_t, seed, multiDrawIndexedInfoEXT.vertexOffset ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MultiDrawInfoEXT { using NativeType = VkMultiDrawInfoEXT; @@ -44525,27 +42133,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMultiDrawInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMultiDrawInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMultiDrawInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkMultiDrawInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( firstVertex, vertexCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MultiDrawInfoEXT const & ) const = default; #else bool operator==( MultiDrawInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( firstVertex == rhs.firstVertex ) && ( vertexCount == rhs.vertexCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( MultiDrawInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -44560,22 +42178,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "MultiDrawInfoEXT is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT const & multiDrawInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, multiDrawInfoEXT.firstVertex ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, multiDrawInfoEXT.vertexCount ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MultisamplePropertiesEXT { using NativeType = VkMultisamplePropertiesEXT; @@ -44604,28 +42206,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkMultisamplePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMultisamplePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMultisamplePropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkMultisamplePropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxSampleLocationGridSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MultisamplePropertiesEXT const & ) const = default; #else bool operator==( MultisamplePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( MultisamplePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -44648,24 +42259,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = MultisamplePropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT const & multisamplePropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, multisamplePropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, multisamplePropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, multisamplePropertiesEXT.maxSampleLocationGridSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MultiviewPerViewAttributesInfoNVX { using NativeType = VkMultiviewPerViewAttributesInfoNVX; @@ -44721,28 +42314,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMultiviewPerViewAttributesInfoNVX const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMultiviewPerViewAttributesInfoNVX const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMultiviewPerViewAttributesInfoNVX &() VULKAN_HPP_NOEXCEPT + explicit operator VkMultiviewPerViewAttributesInfoNVX &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, perViewAttributes, perViewAttributesPositionXOnly ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MultiviewPerViewAttributesInfoNVX const & ) const = default; #else bool operator==( MultiviewPerViewAttributesInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perViewAttributes == rhs.perViewAttributes ) && - ( perViewAttributesPositionXOnly == rhs.perViewAttributesPositionXOnly ); + return this->reflect() == rhs.reflect(); } bool operator!=( MultiviewPerViewAttributesInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -44767,26 +42372,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = MultiviewPerViewAttributesInfoNVX; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX const & - multiviewPerViewAttributesInfoNVX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, multiviewPerViewAttributesInfoNVX.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, multiviewPerViewAttributesInfoNVX.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, multiviewPerViewAttributesInfoNVX.perViewAttributes ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, multiviewPerViewAttributesInfoNVX.perViewAttributesPositionXOnly ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MutableDescriptorTypeListVALVE { using NativeType = VkMutableDescriptorTypeListVALVE; @@ -44852,27 +42437,37 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMutableDescriptorTypeListVALVE const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMutableDescriptorTypeListVALVE const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMutableDescriptorTypeListVALVE &() VULKAN_HPP_NOEXCEPT + explicit operator VkMutableDescriptorTypeListVALVE &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( descriptorTypeCount, pDescriptorTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MutableDescriptorTypeListVALVE const & ) const = default; #else bool operator==( MutableDescriptorTypeListVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( descriptorTypeCount == rhs.descriptorTypeCount ) && ( pDescriptorTypes == rhs.pDescriptorTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( MutableDescriptorTypeListVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -44889,24 +42484,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "MutableDescriptorTypeListVALVE is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE const & mutableDescriptorTypeListVALVE ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, mutableDescriptorTypeListVALVE.descriptorTypeCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::DescriptorType *, seed, mutableDescriptorTypeListVALVE.pDescriptorTypes ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct MutableDescriptorTypeCreateInfoVALVE { using NativeType = VkMutableDescriptorTypeCreateInfoVALVE; @@ -44984,29 +42561,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkMutableDescriptorTypeCreateInfoVALVE const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkMutableDescriptorTypeCreateInfoVALVE const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkMutableDescriptorTypeCreateInfoVALVE &() VULKAN_HPP_NOEXCEPT + explicit operator VkMutableDescriptorTypeCreateInfoVALVE &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, mutableDescriptorTypeListCount, pMutableDescriptorTypeLists ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MutableDescriptorTypeCreateInfoVALVE const & ) const = default; #else bool operator==( MutableDescriptorTypeCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( mutableDescriptorTypeListCount == rhs.mutableDescriptorTypeListCount ) && - ( pMutableDescriptorTypeLists == rhs.pMutableDescriptorTypeLists ); + return this->reflect() == rhs.reflect(); } bool operator!=( MutableDescriptorTypeCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45031,27 +42619,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = MutableDescriptorTypeCreateInfoVALVE; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoVALVE const & - mutableDescriptorTypeCreateInfoVALVE ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, mutableDescriptorTypeCreateInfoVALVE.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, mutableDescriptorTypeCreateInfoVALVE.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, mutableDescriptorTypeCreateInfoVALVE.mutableDescriptorTypeListCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE *, - seed, - mutableDescriptorTypeCreateInfoVALVE.pMutableDescriptorTypeLists ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PastPresentationTimingGOOGLE { using NativeType = VkPastPresentationTimingGOOGLE; @@ -45085,29 +42652,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPastPresentationTimingGOOGLE const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPastPresentationTimingGOOGLE const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPastPresentationTimingGOOGLE &() VULKAN_HPP_NOEXCEPT + explicit operator VkPastPresentationTimingGOOGLE &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( presentID, desiredPresentTime, actualPresentTime, earliestPresentTime, presentMargin ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PastPresentationTimingGOOGLE const & ) const = default; #else bool operator==( PastPresentationTimingGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( presentID == rhs.presentID ) && ( desiredPresentTime == rhs.desiredPresentTime ) && - ( actualPresentTime == rhs.actualPresentTime ) && ( earliestPresentTime == rhs.earliestPresentTime ) && - ( presentMargin == rhs.presentMargin ); + return this->reflect() == rhs.reflect(); } bool operator!=( PastPresentationTimingGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45127,26 +42702,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "PastPresentationTimingGOOGLE is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE const & pastPresentationTimingGOOGLE ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pastPresentationTimingGOOGLE.presentID ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pastPresentationTimingGOOGLE.desiredPresentTime ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pastPresentationTimingGOOGLE.actualPresentTime ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pastPresentationTimingGOOGLE.earliestPresentTime ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pastPresentationTimingGOOGLE.presentMargin ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PerformanceConfigurationAcquireInfoINTEL { using NativeType = VkPerformanceConfigurationAcquireInfoINTEL; @@ -45198,27 +42753,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPerformanceConfigurationAcquireInfoINTEL const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPerformanceConfigurationAcquireInfoINTEL const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPerformanceConfigurationAcquireInfoINTEL &() VULKAN_HPP_NOEXCEPT + explicit operator VkPerformanceConfigurationAcquireInfoINTEL &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceConfigurationAcquireInfoINTEL const & ) const = default; #else bool operator==( PerformanceConfigurationAcquireInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ); + return this->reflect() == rhs.reflect(); } bool operator!=( PerformanceConfigurationAcquireInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45244,26 +42811,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PerformanceConfigurationAcquireInfoINTEL; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & - performanceConfigurationAcquireInfoINTEL ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, performanceConfigurationAcquireInfoINTEL.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceConfigurationAcquireInfoINTEL.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL, seed, performanceConfigurationAcquireInfoINTEL.type ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PerformanceCounterDescriptionKHR { using NativeType = VkPerformanceCounterDescriptionKHR; @@ -45300,28 +42847,42 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPerformanceCounterDescriptionKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPerformanceCounterDescriptionKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPerformanceCounterDescriptionKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPerformanceCounterDescriptionKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, name, category, description ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceCounterDescriptionKHR const & ) const = default; #else bool operator==( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( name == rhs.name ) && - ( category == rhs.category ) && ( description == rhs.description ); + return this->reflect() == rhs.reflect(); } bool operator!=( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45348,38 +42909,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PerformanceCounterDescriptionKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR const & performanceCounterDescriptionKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceCounterDescriptionKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, performanceCounterDescriptionKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsKHR, seed, performanceCounterDescriptionKHR.flags ); - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, performanceCounterDescriptionKHR.name[i] ); - } - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, performanceCounterDescriptionKHR.category[i] ); - } - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, performanceCounterDescriptionKHR.description[i] ); - } - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PerformanceCounterKHR { using NativeType = VkPerformanceCounterKHR; @@ -45416,28 +42945,42 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPerformanceCounterKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPerformanceCounterKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPerformanceCounterKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPerformanceCounterKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, unit, scope, storage, uuid ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceCounterKHR const & ) const = default; #else bool operator==( PerformanceCounterKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( unit == rhs.unit ) && ( scope == rhs.scope ) && - ( storage == rhs.storage ) && ( uuid == rhs.uuid ); + return this->reflect() == rhs.reflect(); } bool operator!=( PerformanceCounterKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45464,30 +43007,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PerformanceCounterKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterKHR const & performanceCounterKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceCounterKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, performanceCounterKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PerformanceCounterUnitKHR, seed, performanceCounterKHR.unit ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR, seed, performanceCounterKHR.scope ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR, seed, performanceCounterKHR.storage ); - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, performanceCounterKHR.uuid[i] ); - } - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ union PerformanceCounterResultKHR { using NativeType = VkPerformanceCounterResultKHR; @@ -45602,27 +43121,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPerformanceMarkerInfoINTEL const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPerformanceMarkerInfoINTEL const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPerformanceMarkerInfoINTEL &() VULKAN_HPP_NOEXCEPT + explicit operator VkPerformanceMarkerInfoINTEL &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, marker ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceMarkerInfoINTEL const & ) const = default; #else bool operator==( PerformanceMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( marker == rhs.marker ); + return this->reflect() == rhs.reflect(); } bool operator!=( PerformanceMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45645,24 +43174,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PerformanceMarkerInfoINTEL; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL const & performanceMarkerInfoINTEL ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceMarkerInfoINTEL.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceMarkerInfoINTEL.pNext ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, performanceMarkerInfoINTEL.marker ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PerformanceOverrideInfoINTEL { using NativeType = VkPerformanceOverrideInfoINTEL; @@ -45725,28 +43236,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPerformanceOverrideInfoINTEL const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPerformanceOverrideInfoINTEL const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPerformanceOverrideInfoINTEL &() VULKAN_HPP_NOEXCEPT + explicit operator VkPerformanceOverrideInfoINTEL &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type, enable, parameter ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceOverrideInfoINTEL const & ) const = default; #else bool operator==( PerformanceOverrideInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( enable == rhs.enable ) && - ( parameter == rhs.parameter ); + return this->reflect() == rhs.reflect(); } bool operator!=( PerformanceOverrideInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45773,27 +43297,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PerformanceOverrideInfoINTEL; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL const & performanceOverrideInfoINTEL ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceOverrideInfoINTEL.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceOverrideInfoINTEL.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL, seed, performanceOverrideInfoINTEL.type ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, performanceOverrideInfoINTEL.enable ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, performanceOverrideInfoINTEL.parameter ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PerformanceQuerySubmitInfoKHR { using NativeType = VkPerformanceQuerySubmitInfoKHR; @@ -45838,27 +43341,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPerformanceQuerySubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPerformanceQuerySubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPerformanceQuerySubmitInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPerformanceQuerySubmitInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, counterPassIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceQuerySubmitInfoKHR const & ) const = default; #else bool operator==( PerformanceQuerySubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( counterPassIndex == rhs.counterPassIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( PerformanceQuerySubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45882,24 +43395,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PerformanceQuerySubmitInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR const & performanceQuerySubmitInfoKHR ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceQuerySubmitInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceQuerySubmitInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, performanceQuerySubmitInfoKHR.counterPassIndex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PerformanceStreamMarkerInfoINTEL { using NativeType = VkPerformanceStreamMarkerInfoINTEL; @@ -45943,27 +43438,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPerformanceStreamMarkerInfoINTEL const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPerformanceStreamMarkerInfoINTEL const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPerformanceStreamMarkerInfoINTEL &() VULKAN_HPP_NOEXCEPT + explicit operator VkPerformanceStreamMarkerInfoINTEL &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, marker ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceStreamMarkerInfoINTEL const & ) const = default; #else bool operator==( PerformanceStreamMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( marker == rhs.marker ); + return this->reflect() == rhs.reflect(); } bool operator!=( PerformanceStreamMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45987,25 +43492,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PerformanceStreamMarkerInfoINTEL; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL const & performanceStreamMarkerInfoINTEL ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, performanceStreamMarkerInfoINTEL.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, performanceStreamMarkerInfoINTEL.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, performanceStreamMarkerInfoINTEL.marker ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ union PerformanceValueDataINTEL { using NativeType = VkPerformanceValueDataINTEL; @@ -46121,16 +43607,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPerformanceValueINTEL const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPerformanceValueINTEL const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPerformanceValueINTEL &() VULKAN_HPP_NOEXCEPT + explicit operator VkPerformanceValueINTEL &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( type, data ); + } + public: VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL type = VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL::eUint32; VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL data = {}; @@ -46216,31 +43713,47 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDevice16BitStorageFeatures const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevice16BitStorageFeatures const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDevice16BitStorageFeatures &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevice16BitStorageFeatures &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + storageBuffer16BitAccess, + uniformAndStorageBuffer16BitAccess, + storagePushConstant16, + storageInputOutput16 ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevice16BitStorageFeatures const & ) const = default; #else - bool operator==( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) && - ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) && - ( storagePushConstant16 == rhs.storagePushConstant16 ) && - ( storageInputOutput16 == rhs.storageInputOutput16 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -46268,31 +43781,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures const & - physicalDevice16BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevice16BitStorageFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevice16BitStorageFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice16BitStorageFeatures.storageBuffer16BitAccess ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice16BitStorageFeatures.uniformAndStorageBuffer16BitAccess ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice16BitStorageFeatures.storagePushConstant16 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice16BitStorageFeatures.storageInputOutput16 ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDevice4444FormatsFeaturesEXT { using NativeType = VkPhysicalDevice4444FormatsFeaturesEXT; @@ -46349,28 +43837,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDevice4444FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevice4444FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDevice4444FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevice4444FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, formatA4R4G4B4, formatA4B4G4R4 ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevice4444FormatsFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatA4R4G4B4 == rhs.formatA4R4G4B4 ) && - ( formatA4B4G4R4 == rhs.formatA4B4G4R4 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -46395,25 +43895,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDevice4444FormatsFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT const & - physicalDevice4444FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevice4444FormatsFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevice4444FormatsFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice4444FormatsFeaturesEXT.formatA4R4G4B4 ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice4444FormatsFeaturesEXT.formatA4B4G4R4 ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDevice8BitStorageFeatures { using NativeType = VkPhysicalDevice8BitStorageFeatures; @@ -46478,30 +43959,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDevice8BitStorageFeatures const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevice8BitStorageFeatures const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDevice8BitStorageFeatures &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevice8BitStorageFeatures &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, storageBuffer8BitAccess, uniformAndStorageBuffer8BitAccess, storagePushConstant8 ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevice8BitStorageFeatures const & ) const = default; #else bool operator==( PhysicalDevice8BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( storageBuffer8BitAccess == rhs.storageBuffer8BitAccess ) && - ( uniformAndStorageBuffer8BitAccess == rhs.uniformAndStorageBuffer8BitAccess ) && - ( storagePushConstant8 == rhs.storagePushConstant8 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevice8BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -46528,29 +44020,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures const & - physicalDevice8BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevice8BitStorageFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevice8BitStorageFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice8BitStorageFeatures.storageBuffer8BitAccess ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice8BitStorageFeatures.uniformAndStorageBuffer8BitAccess ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevice8BitStorageFeatures.storagePushConstant8 ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceASTCDecodeFeaturesEXT { using NativeType = VkPhysicalDeviceASTCDecodeFeaturesEXT; @@ -46598,28 +44067,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceASTCDecodeFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceASTCDecodeFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceASTCDecodeFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceASTCDecodeFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, decodeModeSharedExponent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceASTCDecodeFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( decodeModeSharedExponent == rhs.decodeModeSharedExponent ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -46643,25 +44121,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceASTCDecodeFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT const & - physicalDeviceASTCDecodeFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceASTCDecodeFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceASTCDecodeFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceASTCDecodeFeaturesEXT.decodeModeSharedExponent ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceAccelerationStructureFeaturesKHR { using NativeType = VkPhysicalDeviceAccelerationStructureFeaturesKHR; @@ -46749,33 +44208,49 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceAccelerationStructureFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceAccelerationStructureFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceAccelerationStructureFeaturesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceAccelerationStructureFeaturesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + accelerationStructure, + accelerationStructureCaptureReplay, + accelerationStructureIndirectBuild, + accelerationStructureHostCommands, + descriptorBindingAccelerationStructureUpdateAfterBind ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceAccelerationStructureFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( accelerationStructure == rhs.accelerationStructure ) && - ( accelerationStructureCaptureReplay == rhs.accelerationStructureCaptureReplay ) && - ( accelerationStructureIndirectBuild == rhs.accelerationStructureIndirectBuild ) && - ( accelerationStructureHostCommands == rhs.accelerationStructureHostCommands ) && - ( descriptorBindingAccelerationStructureUpdateAfterBind == - rhs.descriptorBindingAccelerationStructureUpdateAfterBind ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -46804,39 +44279,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceAccelerationStructureFeaturesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR const & - physicalDeviceAccelerationStructureFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceAccelerationStructureFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceAccelerationStructureFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureCaptureReplay ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureIndirectBuild ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureHostCommands ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceAccelerationStructureFeaturesKHR.descriptorBindingAccelerationStructureUpdateAfterBind ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceAccelerationStructurePropertiesKHR { using NativeType = VkPhysicalDeviceAccelerationStructurePropertiesKHR; @@ -46886,35 +44328,55 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceAccelerationStructurePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceAccelerationStructurePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceAccelerationStructurePropertiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceAccelerationStructurePropertiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxGeometryCount, + maxInstanceCount, + maxPrimitiveCount, + maxPerStageDescriptorAccelerationStructures, + maxPerStageDescriptorUpdateAfterBindAccelerationStructures, + maxDescriptorSetAccelerationStructures, + maxDescriptorSetUpdateAfterBindAccelerationStructures, + minAccelerationStructureScratchOffsetAlignment ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceAccelerationStructurePropertiesKHR const & ) const = default; #else bool operator==( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxGeometryCount == rhs.maxGeometryCount ) && - ( maxInstanceCount == rhs.maxInstanceCount ) && ( maxPrimitiveCount == rhs.maxPrimitiveCount ) && - ( maxPerStageDescriptorAccelerationStructures == rhs.maxPerStageDescriptorAccelerationStructures ) && - ( maxPerStageDescriptorUpdateAfterBindAccelerationStructures == - rhs.maxPerStageDescriptorUpdateAfterBindAccelerationStructures ) && - ( maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures ) && - ( maxDescriptorSetUpdateAfterBindAccelerationStructures == - rhs.maxDescriptorSetUpdateAfterBindAccelerationStructures ) && - ( minAccelerationStructureScratchOffsetAlignment == rhs.minAccelerationStructureScratchOffsetAlignment ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -46946,41 +44408,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceAccelerationStructurePropertiesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR const & - physicalDeviceAccelerationStructurePropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceAccelerationStructurePropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceAccelerationStructurePropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxGeometryCount ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxInstanceCount ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPrimitiveCount ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorAccelerationStructures ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, - seed, - physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorUpdateAfterBindAccelerationStructures ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetAccelerationStructures ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, - seed, - physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetUpdateAfterBindAccelerationStructures ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceAccelerationStructurePropertiesKHR.minAccelerationStructureScratchOffsetAlignment ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT { using NativeType = VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; @@ -47031,28 +44458,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, advancedBlendCoherentOperations ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( advancedBlendCoherentOperations == rhs.advancedBlendCoherentOperations ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -47077,27 +44513,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceBlendOperationAdvancedFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & - physicalDeviceBlendOperationAdvancedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceBlendOperationAdvancedFeaturesEXT.advancedBlendCoherentOperations ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT { using NativeType = VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; @@ -47143,33 +44558,51 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + advancedBlendMaxColorAttachments, + advancedBlendIndependentBlend, + advancedBlendNonPremultipliedSrcColor, + advancedBlendNonPremultipliedDstColor, + advancedBlendCorrelatedOverlap, + advancedBlendAllOperations ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( advancedBlendMaxColorAttachments == rhs.advancedBlendMaxColorAttachments ) && - ( advancedBlendIndependentBlend == rhs.advancedBlendIndependentBlend ) && - ( advancedBlendNonPremultipliedSrcColor == rhs.advancedBlendNonPremultipliedSrcColor ) && - ( advancedBlendNonPremultipliedDstColor == rhs.advancedBlendNonPremultipliedDstColor ) && - ( advancedBlendCorrelatedOverlap == rhs.advancedBlendCorrelatedOverlap ) && - ( advancedBlendAllOperations == rhs.advancedBlendAllOperations ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -47199,41 +44632,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceBlendOperationAdvancedPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & - physicalDeviceBlendOperationAdvancedPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendMaxColorAttachments ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendIndependentBlend ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedSrcColor ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedDstColor ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendCorrelatedOverlap ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendAllOperations ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceBorderColorSwizzleFeaturesEXT { using NativeType = VkPhysicalDeviceBorderColorSwizzleFeaturesEXT; @@ -47292,28 +44690,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, borderColorSwizzle, borderColorSwizzleFromImage ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( borderColorSwizzle == rhs.borderColorSwizzle ) && - ( borderColorSwizzleFromImage == rhs.borderColorSwizzleFromImage ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -47339,28 +44749,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceBorderColorSwizzleFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT const & - physicalDeviceBorderColorSwizzleFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBorderColorSwizzleFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBorderColorSwizzleFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzle ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzleFromImage ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceBufferDeviceAddressFeatures { using NativeType = VkPhysicalDeviceBufferDeviceAddressFeatures; @@ -47428,29 +44816,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceBufferDeviceAddressFeatures const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceBufferDeviceAddressFeatures const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceBufferDeviceAddressFeatures &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceBufferDeviceAddressFeatures &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, bufferDeviceAddress, bufferDeviceAddressCaptureReplay, bufferDeviceAddressMultiDevice ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceBufferDeviceAddressFeatures const & ) const = default; #else bool operator==( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) && - ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) && - ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -47478,30 +44879,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures const & - physicalDeviceBufferDeviceAddressFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBufferDeviceAddressFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBufferDeviceAddressFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddress ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressCaptureReplay ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressMultiDevice ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceBufferDeviceAddressFeaturesEXT { using NativeType = VkPhysicalDeviceBufferDeviceAddressFeaturesEXT; @@ -47569,29 +44946,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, bufferDeviceAddress, bufferDeviceAddressCaptureReplay, bufferDeviceAddressMultiDevice ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) && - ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) && - ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -47619,31 +45009,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT const & - physicalDeviceBufferDeviceAddressFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceBufferDeviceAddressFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceBufferDeviceAddressFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddress ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressCaptureReplay ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressMultiDevice ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceCoherentMemoryFeaturesAMD { using NativeType = VkPhysicalDeviceCoherentMemoryFeaturesAMD; @@ -47692,27 +45057,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceCoherentMemoryFeaturesAMD const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceCoherentMemoryFeaturesAMD const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceCoherentMemoryFeaturesAMD &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceCoherentMemoryFeaturesAMD &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceCoherentMemory ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCoherentMemoryFeaturesAMD const & ) const = default; #else bool operator==( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceCoherentMemory == rhs.deviceCoherentMemory ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -47737,25 +45112,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceCoherentMemoryFeaturesAMD; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD const & - physicalDeviceCoherentMemoryFeaturesAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCoherentMemoryFeaturesAMD.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCoherentMemoryFeaturesAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCoherentMemoryFeaturesAMD.deviceCoherentMemory ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceColorWriteEnableFeaturesEXT { using NativeType = VkPhysicalDeviceColorWriteEnableFeaturesEXT; @@ -47804,27 +45160,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceColorWriteEnableFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceColorWriteEnableFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceColorWriteEnableFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceColorWriteEnableFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, colorWriteEnable ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceColorWriteEnableFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorWriteEnable == rhs.colorWriteEnable ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -47849,26 +45215,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceColorWriteEnableFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT const & - physicalDeviceColorWriteEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceColorWriteEnableFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceColorWriteEnableFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceColorWriteEnableFeaturesEXT.colorWriteEnable ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceComputeShaderDerivativesFeaturesNV { using NativeType = VkPhysicalDeviceComputeShaderDerivativesFeaturesNV; @@ -47928,29 +45274,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, computeDerivativeGroupQuads, computeDerivativeGroupLinear ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( computeDerivativeGroupQuads == rhs.computeDerivativeGroupQuads ) && - ( computeDerivativeGroupLinear == rhs.computeDerivativeGroupLinear ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -47976,30 +45333,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceComputeShaderDerivativesFeaturesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV const & - physicalDeviceComputeShaderDerivativesFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceComputeShaderDerivativesFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceComputeShaderDerivativesFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupQuads ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupLinear ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceConditionalRenderingFeaturesEXT { using NativeType = VkPhysicalDeviceConditionalRenderingFeaturesEXT; @@ -48059,28 +45392,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceConditionalRenderingFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceConditionalRenderingFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceConditionalRenderingFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceConditionalRenderingFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, conditionalRendering, inheritedConditionalRendering ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceConditionalRenderingFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conditionalRendering == rhs.conditionalRendering ) && - ( inheritedConditionalRendering == rhs.inheritedConditionalRendering ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48106,28 +45451,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceConditionalRenderingFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT const & - physicalDeviceConditionalRenderingFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceConditionalRenderingFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceConditionalRenderingFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceConditionalRenderingFeaturesEXT.conditionalRendering ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceConditionalRenderingFeaturesEXT.inheritedConditionalRendering ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceConservativeRasterizationPropertiesEXT { using NativeType = VkPhysicalDeviceConservativeRasterizationPropertiesEXT; @@ -48179,36 +45502,57 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + primitiveOverestimationSize, + maxExtraPrimitiveOverestimationSize, + extraPrimitiveOverestimationSizeGranularity, + primitiveUnderestimation, + conservativePointAndLineRasterization, + degenerateTrianglesRasterized, + degenerateLinesRasterized, + fullyCoveredFragmentShaderInputVariable, + conservativeRasterizationPostDepthCoverage ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceConservativeRasterizationPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( primitiveOverestimationSize == rhs.primitiveOverestimationSize ) && - ( maxExtraPrimitiveOverestimationSize == rhs.maxExtraPrimitiveOverestimationSize ) && - ( extraPrimitiveOverestimationSizeGranularity == rhs.extraPrimitiveOverestimationSizeGranularity ) && - ( primitiveUnderestimation == rhs.primitiveUnderestimation ) && - ( conservativePointAndLineRasterization == rhs.conservativePointAndLineRasterization ) && - ( degenerateTrianglesRasterized == rhs.degenerateTrianglesRasterized ) && - ( degenerateLinesRasterized == rhs.degenerateLinesRasterized ) && - ( fullyCoveredFragmentShaderInputVariable == rhs.fullyCoveredFragmentShaderInputVariable ) && - ( conservativeRasterizationPostDepthCoverage == rhs.conservativeRasterizationPostDepthCoverage ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48241,51 +45585,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceConservativeRasterizationPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT const & - physicalDeviceConservativeRasterizationPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceConservativeRasterizationPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceConservativeRasterizationPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - float, seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveOverestimationSize ); - VULKAN_HPP_HASH_COMBINE( - float, seed, physicalDeviceConservativeRasterizationPropertiesEXT.maxExtraPrimitiveOverestimationSize ); - VULKAN_HPP_HASH_COMBINE( - float, seed, physicalDeviceConservativeRasterizationPropertiesEXT.extraPrimitiveOverestimationSizeGranularity ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceConservativeRasterizationPropertiesEXT.primitiveUnderestimation ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceConservativeRasterizationPropertiesEXT.conservativePointAndLineRasterization ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceConservativeRasterizationPropertiesEXT.degenerateTrianglesRasterized ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceConservativeRasterizationPropertiesEXT.degenerateLinesRasterized ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceConservativeRasterizationPropertiesEXT.fullyCoveredFragmentShaderInputVariable ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceConservativeRasterizationPropertiesEXT.conservativeRasterizationPostDepthCoverage ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceCooperativeMatrixFeaturesNV { using NativeType = VkPhysicalDeviceCooperativeMatrixFeaturesNV; @@ -48344,28 +45643,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceCooperativeMatrixFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceCooperativeMatrixFeaturesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceCooperativeMatrixFeaturesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceCooperativeMatrixFeaturesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, cooperativeMatrix, cooperativeMatrixRobustBufferAccess ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCooperativeMatrixFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrix == rhs.cooperativeMatrix ) && - ( cooperativeMatrixRobustBufferAccess == rhs.cooperativeMatrixRobustBufferAccess ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48391,29 +45702,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceCooperativeMatrixFeaturesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV const & - physicalDeviceCooperativeMatrixFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCooperativeMatrixFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCooperativeMatrixFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrix ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrixRobustBufferAccess ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceCooperativeMatrixPropertiesNV { using NativeType = VkPhysicalDeviceCooperativeMatrixPropertiesNV; @@ -48448,28 +45736,38 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceCooperativeMatrixPropertiesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceCooperativeMatrixPropertiesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std:: + tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, cooperativeMatrixSupportedStages ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCooperativeMatrixPropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( cooperativeMatrixSupportedStages == rhs.cooperativeMatrixSupportedStages ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48494,27 +45792,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceCooperativeMatrixPropertiesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV const & - physicalDeviceCooperativeMatrixPropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCooperativeMatrixPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCooperativeMatrixPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags, - seed, - physicalDeviceCooperativeMatrixPropertiesNV.cooperativeMatrixSupportedStages ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceCornerSampledImageFeaturesNV { using NativeType = VkPhysicalDeviceCornerSampledImageFeaturesNV; @@ -48564,27 +45841,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceCornerSampledImageFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceCornerSampledImageFeaturesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceCornerSampledImageFeaturesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceCornerSampledImageFeaturesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, cornerSampledImage ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCornerSampledImageFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cornerSampledImage == rhs.cornerSampledImage ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48609,26 +45896,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceCornerSampledImageFeaturesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV const & - physicalDeviceCornerSampledImageFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCornerSampledImageFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCornerSampledImageFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCornerSampledImageFeaturesNV.cornerSampledImage ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceCoverageReductionModeFeaturesNV { using NativeType = VkPhysicalDeviceCoverageReductionModeFeaturesNV; @@ -48679,27 +45946,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceCoverageReductionModeFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceCoverageReductionModeFeaturesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceCoverageReductionModeFeaturesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceCoverageReductionModeFeaturesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, coverageReductionMode ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCoverageReductionModeFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( coverageReductionMode == rhs.coverageReductionMode ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48724,26 +46001,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceCoverageReductionModeFeaturesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV const & - physicalDeviceCoverageReductionModeFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCoverageReductionModeFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCoverageReductionModeFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCoverageReductionModeFeaturesNV.coverageReductionMode ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceCustomBorderColorFeaturesEXT { using NativeType = VkPhysicalDeviceCustomBorderColorFeaturesEXT; @@ -48802,28 +46059,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceCustomBorderColorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceCustomBorderColorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceCustomBorderColorFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceCustomBorderColorFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, customBorderColors, customBorderColorWithoutFormat ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCustomBorderColorFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( customBorderColors == rhs.customBorderColors ) && - ( customBorderColorWithoutFormat == rhs.customBorderColorWithoutFormat ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48849,28 +46118,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceCustomBorderColorFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT const & - physicalDeviceCustomBorderColorFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCustomBorderColorFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCustomBorderColorFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColors ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColorWithoutFormat ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceCustomBorderColorPropertiesEXT { using NativeType = VkPhysicalDeviceCustomBorderColorPropertiesEXT; @@ -48905,28 +46152,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceCustomBorderColorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceCustomBorderColorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceCustomBorderColorPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceCustomBorderColorPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxCustomBorderColorSamplers ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCustomBorderColorPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxCustomBorderColorSamplers == rhs.maxCustomBorderColorSamplers ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48951,26 +46207,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceCustomBorderColorPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT const & - physicalDeviceCustomBorderColorPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceCustomBorderColorPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceCustomBorderColorPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceCustomBorderColorPropertiesEXT.maxCustomBorderColorSamplers ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { using NativeType = VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; @@ -49023,28 +46259,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dedicatedAllocationImageAliasing ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( dedicatedAllocationImageAliasing == rhs.dedicatedAllocationImageAliasing ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -49071,28 +46316,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & - physicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.dedicatedAllocationImageAliasing ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceDepthClipControlFeaturesEXT { using NativeType = VkPhysicalDeviceDepthClipControlFeaturesEXT; @@ -49141,27 +46364,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceDepthClipControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDepthClipControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceDepthClipControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDepthClipControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, depthClipControl ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDepthClipControlFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClipControl == rhs.depthClipControl ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -49186,26 +46419,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceDepthClipControlFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT const & - physicalDeviceDepthClipControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDepthClipControlFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDepthClipControlFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDepthClipControlFeaturesEXT.depthClipControl ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceDepthClipEnableFeaturesEXT { using NativeType = VkPhysicalDeviceDepthClipEnableFeaturesEXT; @@ -49255,27 +46468,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceDepthClipEnableFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDepthClipEnableFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceDepthClipEnableFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDepthClipEnableFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, depthClipEnable ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDepthClipEnableFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClipEnable == rhs.depthClipEnable ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -49300,26 +46523,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceDepthClipEnableFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT const & - physicalDeviceDepthClipEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDepthClipEnableFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDepthClipEnableFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDepthClipEnableFeaturesEXT.depthClipEnable ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceDepthStencilResolveProperties { using NativeType = VkPhysicalDeviceDepthStencilResolveProperties; @@ -49360,31 +46563,47 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceDepthStencilResolveProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDepthStencilResolveProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceDepthStencilResolveProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDepthStencilResolveProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + supportedDepthResolveModes, + supportedStencilResolveModes, + independentResolveNone, + independentResolve ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDepthStencilResolveProperties const & ) const = default; #else bool operator==( PhysicalDeviceDepthStencilResolveProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( supportedDepthResolveModes == rhs.supportedDepthResolveModes ) && - ( supportedStencilResolveModes == rhs.supportedStencilResolveModes ) && - ( independentResolveNone == rhs.independentResolveNone ) && - ( independentResolve == rhs.independentResolve ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDepthStencilResolveProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -49413,34 +46632,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties const & - physicalDeviceDepthStencilResolveProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDepthStencilResolveProperties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDepthStencilResolveProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ResolveModeFlags, - seed, - physicalDeviceDepthStencilResolveProperties.supportedDepthResolveModes ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ResolveModeFlags, - seed, - physicalDeviceDepthStencilResolveProperties.supportedStencilResolveModes ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDepthStencilResolveProperties.independentResolveNone ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDepthStencilResolveProperties.independentResolve ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceDescriptorIndexingFeatures { using NativeType = VkPhysicalDeviceDescriptorIndexingFeatures; @@ -49665,51 +46856,79 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceDescriptorIndexingFeatures const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDescriptorIndexingFeatures const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceDescriptorIndexingFeatures &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDescriptorIndexingFeatures &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderInputAttachmentArrayDynamicIndexing, + shaderUniformTexelBufferArrayDynamicIndexing, + shaderStorageTexelBufferArrayDynamicIndexing, + shaderUniformBufferArrayNonUniformIndexing, + shaderSampledImageArrayNonUniformIndexing, + shaderStorageBufferArrayNonUniformIndexing, + shaderStorageImageArrayNonUniformIndexing, + shaderInputAttachmentArrayNonUniformIndexing, + shaderUniformTexelBufferArrayNonUniformIndexing, + shaderStorageTexelBufferArrayNonUniformIndexing, + descriptorBindingUniformBufferUpdateAfterBind, + descriptorBindingSampledImageUpdateAfterBind, + descriptorBindingStorageImageUpdateAfterBind, + descriptorBindingStorageBufferUpdateAfterBind, + descriptorBindingUniformTexelBufferUpdateAfterBind, + descriptorBindingStorageTexelBufferUpdateAfterBind, + descriptorBindingUpdateUnusedWhilePending, + descriptorBindingPartiallyBound, + descriptorBindingVariableDescriptorCount, + runtimeDescriptorArray ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDescriptorIndexingFeatures const & ) const = default; #else bool operator==( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderInputAttachmentArrayDynamicIndexing == rhs.shaderInputAttachmentArrayDynamicIndexing ) && - ( shaderUniformTexelBufferArrayDynamicIndexing == rhs.shaderUniformTexelBufferArrayDynamicIndexing ) && - ( shaderStorageTexelBufferArrayDynamicIndexing == rhs.shaderStorageTexelBufferArrayDynamicIndexing ) && - ( shaderUniformBufferArrayNonUniformIndexing == rhs.shaderUniformBufferArrayNonUniformIndexing ) && - ( shaderSampledImageArrayNonUniformIndexing == rhs.shaderSampledImageArrayNonUniformIndexing ) && - ( shaderStorageBufferArrayNonUniformIndexing == rhs.shaderStorageBufferArrayNonUniformIndexing ) && - ( shaderStorageImageArrayNonUniformIndexing == rhs.shaderStorageImageArrayNonUniformIndexing ) && - ( shaderInputAttachmentArrayNonUniformIndexing == rhs.shaderInputAttachmentArrayNonUniformIndexing ) && - ( shaderUniformTexelBufferArrayNonUniformIndexing == - rhs.shaderUniformTexelBufferArrayNonUniformIndexing ) && - ( shaderStorageTexelBufferArrayNonUniformIndexing == - rhs.shaderStorageTexelBufferArrayNonUniformIndexing ) && - ( descriptorBindingUniformBufferUpdateAfterBind == rhs.descriptorBindingUniformBufferUpdateAfterBind ) && - ( descriptorBindingSampledImageUpdateAfterBind == rhs.descriptorBindingSampledImageUpdateAfterBind ) && - ( descriptorBindingStorageImageUpdateAfterBind == rhs.descriptorBindingStorageImageUpdateAfterBind ) && - ( descriptorBindingStorageBufferUpdateAfterBind == rhs.descriptorBindingStorageBufferUpdateAfterBind ) && - ( descriptorBindingUniformTexelBufferUpdateAfterBind == - rhs.descriptorBindingUniformTexelBufferUpdateAfterBind ) && - ( descriptorBindingStorageTexelBufferUpdateAfterBind == - rhs.descriptorBindingStorageTexelBufferUpdateAfterBind ) && - ( descriptorBindingUpdateUnusedWhilePending == rhs.descriptorBindingUpdateUnusedWhilePending ) && - ( descriptorBindingPartiallyBound == rhs.descriptorBindingPartiallyBound ) && - ( descriptorBindingVariableDescriptorCount == rhs.descriptorBindingVariableDescriptorCount ) && - ( runtimeDescriptorArray == rhs.runtimeDescriptorArray ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -49754,84 +46973,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures const & - physicalDeviceDescriptorIndexingFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDescriptorIndexingFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDescriptorIndexingFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingFeatures.shaderUniformBufferArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingFeatures.shaderStorageImageArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformBufferUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingFeatures.descriptorBindingVariableDescriptorCount ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceDescriptorIndexingProperties { using NativeType = VkPhysicalDeviceDescriptorIndexingProperties; @@ -49910,62 +47051,85 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceDescriptorIndexingProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDescriptorIndexingProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceDescriptorIndexingProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDescriptorIndexingProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxUpdateAfterBindDescriptorsInAllPools, + shaderUniformBufferArrayNonUniformIndexingNative, + shaderSampledImageArrayNonUniformIndexingNative, + shaderStorageBufferArrayNonUniformIndexingNative, + shaderStorageImageArrayNonUniformIndexingNative, + shaderInputAttachmentArrayNonUniformIndexingNative, + robustBufferAccessUpdateAfterBind, + quadDivergentImplicitLod, + maxPerStageDescriptorUpdateAfterBindSamplers, + maxPerStageDescriptorUpdateAfterBindUniformBuffers, + maxPerStageDescriptorUpdateAfterBindStorageBuffers, + maxPerStageDescriptorUpdateAfterBindSampledImages, + maxPerStageDescriptorUpdateAfterBindStorageImages, + maxPerStageDescriptorUpdateAfterBindInputAttachments, + maxPerStageUpdateAfterBindResources, + maxDescriptorSetUpdateAfterBindSamplers, + maxDescriptorSetUpdateAfterBindUniformBuffers, + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, + maxDescriptorSetUpdateAfterBindStorageBuffers, + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, + maxDescriptorSetUpdateAfterBindSampledImages, + maxDescriptorSetUpdateAfterBindStorageImages, + maxDescriptorSetUpdateAfterBindInputAttachments ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDescriptorIndexingProperties const & ) const = default; #else bool operator==( PhysicalDeviceDescriptorIndexingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxUpdateAfterBindDescriptorsInAllPools == rhs.maxUpdateAfterBindDescriptorsInAllPools ) && - ( shaderUniformBufferArrayNonUniformIndexingNative == - rhs.shaderUniformBufferArrayNonUniformIndexingNative ) && - ( shaderSampledImageArrayNonUniformIndexingNative == - rhs.shaderSampledImageArrayNonUniformIndexingNative ) && - ( shaderStorageBufferArrayNonUniformIndexingNative == - rhs.shaderStorageBufferArrayNonUniformIndexingNative ) && - ( shaderStorageImageArrayNonUniformIndexingNative == - rhs.shaderStorageImageArrayNonUniformIndexingNative ) && - ( shaderInputAttachmentArrayNonUniformIndexingNative == - rhs.shaderInputAttachmentArrayNonUniformIndexingNative ) && - ( robustBufferAccessUpdateAfterBind == rhs.robustBufferAccessUpdateAfterBind ) && - ( quadDivergentImplicitLod == rhs.quadDivergentImplicitLod ) && - ( maxPerStageDescriptorUpdateAfterBindSamplers == rhs.maxPerStageDescriptorUpdateAfterBindSamplers ) && - ( maxPerStageDescriptorUpdateAfterBindUniformBuffers == - rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers ) && - ( maxPerStageDescriptorUpdateAfterBindStorageBuffers == - rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers ) && - ( maxPerStageDescriptorUpdateAfterBindSampledImages == - rhs.maxPerStageDescriptorUpdateAfterBindSampledImages ) && - ( maxPerStageDescriptorUpdateAfterBindStorageImages == - rhs.maxPerStageDescriptorUpdateAfterBindStorageImages ) && - ( maxPerStageDescriptorUpdateAfterBindInputAttachments == - rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments ) && - ( maxPerStageUpdateAfterBindResources == rhs.maxPerStageUpdateAfterBindResources ) && - ( maxDescriptorSetUpdateAfterBindSamplers == rhs.maxDescriptorSetUpdateAfterBindSamplers ) && - ( maxDescriptorSetUpdateAfterBindUniformBuffers == rhs.maxDescriptorSetUpdateAfterBindUniformBuffers ) && - ( maxDescriptorSetUpdateAfterBindUniformBuffersDynamic == - rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ) && - ( maxDescriptorSetUpdateAfterBindStorageBuffers == rhs.maxDescriptorSetUpdateAfterBindStorageBuffers ) && - ( maxDescriptorSetUpdateAfterBindStorageBuffersDynamic == - rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ) && - ( maxDescriptorSetUpdateAfterBindSampledImages == rhs.maxDescriptorSetUpdateAfterBindSampledImages ) && - ( maxDescriptorSetUpdateAfterBindStorageImages == rhs.maxDescriptorSetUpdateAfterBindStorageImages ) && - ( maxDescriptorSetUpdateAfterBindInputAttachments == rhs.maxDescriptorSetUpdateAfterBindInputAttachments ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDescriptorIndexingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50013,81 +47177,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties const & - physicalDeviceDescriptorIndexingProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDescriptorIndexingProperties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDescriptorIndexingProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxUpdateAfterBindDescriptorsInAllPools ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingProperties.shaderUniformBufferArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingProperties.shaderSampledImageArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingProperties.shaderStorageBufferArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingProperties.shaderStorageImageArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingProperties.shaderInputAttachmentArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceDescriptorIndexingProperties.robustBufferAccessUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDescriptorIndexingProperties.quadDivergentImplicitLod ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSamplers ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindUniformBuffers ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageBuffers ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSampledImages ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageImages ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindInputAttachments ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxPerStageUpdateAfterBindResources ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSamplers ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffers ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffers ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSampledImages ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageImages ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindInputAttachments ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV { using NativeType = VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV; @@ -50138,28 +47227,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceGeneratedCommands ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( deviceGeneratedCommands == rhs.deviceGeneratedCommands ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50184,26 +47282,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & - physicalDeviceDeviceGeneratedCommandsFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.deviceGeneratedCommands ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { using NativeType = VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV; @@ -50255,36 +47333,57 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxGraphicsShaderGroupCount, + maxIndirectSequenceCount, + maxIndirectCommandsTokenCount, + maxIndirectCommandsStreamCount, + maxIndirectCommandsTokenOffset, + maxIndirectCommandsStreamStride, + minSequencesCountBufferOffsetAlignment, + minSequencesIndexBufferOffsetAlignment, + minIndirectCommandsBufferOffsetAlignment ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxGraphicsShaderGroupCount == rhs.maxGraphicsShaderGroupCount ) && - ( maxIndirectSequenceCount == rhs.maxIndirectSequenceCount ) && - ( maxIndirectCommandsTokenCount == rhs.maxIndirectCommandsTokenCount ) && - ( maxIndirectCommandsStreamCount == rhs.maxIndirectCommandsStreamCount ) && - ( maxIndirectCommandsTokenOffset == rhs.maxIndirectCommandsTokenOffset ) && - ( maxIndirectCommandsStreamStride == rhs.maxIndirectCommandsStreamStride ) && - ( minSequencesCountBufferOffsetAlignment == rhs.minSequencesCountBufferOffsetAlignment ) && - ( minSequencesIndexBufferOffsetAlignment == rhs.minSequencesIndexBufferOffsetAlignment ) && - ( minIndirectCommandsBufferOffsetAlignment == rhs.minIndirectCommandsBufferOffsetAlignment ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50317,42 +47416,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & - physicalDeviceDeviceGeneratedCommandsPropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxGraphicsShaderGroupCount ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectSequenceCount ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenCount ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamCount ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenOffset ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamStride ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesCountBufferOffsetAlignment ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesIndexBufferOffsetAlignment ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minIndirectCommandsBufferOffsetAlignment ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceDeviceMemoryReportFeaturesEXT { using NativeType = VkPhysicalDeviceDeviceMemoryReportFeaturesEXT; @@ -50402,27 +47465,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceMemoryReport ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMemoryReport == rhs.deviceMemoryReport ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50447,26 +47520,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceDeviceMemoryReportFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT const & - physicalDeviceDeviceMemoryReportFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDeviceMemoryReportFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDeviceMemoryReportFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDeviceMemoryReportFeaturesEXT.deviceMemoryReport ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceDiagnosticsConfigFeaturesNV { using NativeType = VkPhysicalDeviceDiagnosticsConfigFeaturesNV; @@ -50516,27 +47569,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, diagnosticsConfig ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDiagnosticsConfigFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( diagnosticsConfig == rhs.diagnosticsConfig ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50561,26 +47624,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceDiagnosticsConfigFeaturesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV const & - physicalDeviceDiagnosticsConfigFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDiagnosticsConfigFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDiagnosticsConfigFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDiagnosticsConfigFeaturesNV.diagnosticsConfig ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceDiscardRectanglePropertiesEXT { using NativeType = VkPhysicalDeviceDiscardRectanglePropertiesEXT; @@ -50615,27 +47658,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceDiscardRectanglePropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDiscardRectanglePropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxDiscardRectangles ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDiscardRectanglePropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxDiscardRectangles == rhs.maxDiscardRectangles ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50660,25 +47713,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceDiscardRectanglePropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT const & - physicalDeviceDiscardRectanglePropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDiscardRectanglePropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDiscardRectanglePropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceDiscardRectanglePropertiesEXT.maxDiscardRectangles ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceDriverProperties { using NativeType = VkPhysicalDeviceDriverProperties; @@ -50715,29 +47749,42 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceDriverProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDriverProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceDriverProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDriverProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::ConformanceVersion const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, driverID, driverName, driverInfo, conformanceVersion ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDriverProperties const & ) const = default; #else bool operator==( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) && - ( driverName == rhs.driverName ) && ( driverInfo == rhs.driverInfo ) && - ( conformanceVersion == rhs.conformanceVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50765,34 +47812,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties const & physicalDeviceDriverProperties ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDriverProperties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDriverProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DriverId, seed, physicalDeviceDriverProperties.driverID ); - for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceDriverProperties.driverName[i] ); - } - for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceDriverProperties.driverInfo[i] ); - } - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ConformanceVersion, seed, physicalDeviceDriverProperties.conformanceVersion ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceDrmPropertiesEXT { using NativeType = VkPhysicalDeviceDrmPropertiesEXT; @@ -50832,30 +47851,44 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceDrmPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDrmPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceDrmPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDrmPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, hasPrimary, hasRender, primaryMajor, primaryMinor, renderMajor, renderMinor ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDrmPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceDrmPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasPrimary == rhs.hasPrimary ) && - ( hasRender == rhs.hasRender ) && ( primaryMajor == rhs.primaryMajor ) && - ( primaryMinor == rhs.primaryMinor ) && ( renderMajor == rhs.renderMajor ) && - ( renderMinor == rhs.renderMinor ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDrmPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50884,29 +47917,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceDrmPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT const & physicalDeviceDrmPropertiesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDrmPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDrmPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDrmPropertiesEXT.hasPrimary ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDrmPropertiesEXT.hasRender ); - VULKAN_HPP_HASH_COMBINE( int64_t, seed, physicalDeviceDrmPropertiesEXT.primaryMajor ); - VULKAN_HPP_HASH_COMBINE( int64_t, seed, physicalDeviceDrmPropertiesEXT.primaryMinor ); - VULKAN_HPP_HASH_COMBINE( int64_t, seed, physicalDeviceDrmPropertiesEXT.renderMajor ); - VULKAN_HPP_HASH_COMBINE( int64_t, seed, physicalDeviceDrmPropertiesEXT.renderMinor ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceDynamicRenderingFeaturesKHR { using NativeType = VkPhysicalDeviceDynamicRenderingFeaturesKHR; @@ -50955,27 +47965,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceDynamicRenderingFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDynamicRenderingFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceDynamicRenderingFeaturesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceDynamicRenderingFeaturesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dynamicRendering ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDynamicRenderingFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceDynamicRenderingFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicRendering == rhs.dynamicRendering ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDynamicRenderingFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51000,26 +48020,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceDynamicRenderingFeaturesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeaturesKHR const & - physicalDeviceDynamicRenderingFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceDynamicRenderingFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceDynamicRenderingFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceDynamicRenderingFeaturesKHR.dynamicRendering ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceExclusiveScissorFeaturesNV { using NativeType = VkPhysicalDeviceExclusiveScissorFeaturesNV; @@ -51068,27 +48068,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceExclusiveScissorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceExclusiveScissorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceExclusiveScissorFeaturesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceExclusiveScissorFeaturesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, exclusiveScissor ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExclusiveScissorFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exclusiveScissor == rhs.exclusiveScissor ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51113,26 +48123,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceExclusiveScissorFeaturesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV const & - physicalDeviceExclusiveScissorFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExclusiveScissorFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExclusiveScissorFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExclusiveScissorFeaturesNV.exclusiveScissor ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceExtendedDynamicState2FeaturesEXT { using NativeType = VkPhysicalDeviceExtendedDynamicState2FeaturesEXT; @@ -51201,30 +48191,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, extendedDynamicState2, extendedDynamicState2LogicOp, extendedDynamicState2PatchControlPoints ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( extendedDynamicState2 == rhs.extendedDynamicState2 ) && - ( extendedDynamicState2LogicOp == rhs.extendedDynamicState2LogicOp ) && - ( extendedDynamicState2PatchControlPoints == rhs.extendedDynamicState2PatchControlPoints ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51251,31 +48253,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceExtendedDynamicState2FeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT const & - physicalDeviceExtendedDynamicState2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExtendedDynamicState2FeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExtendedDynamicState2FeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2LogicOp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2PatchControlPoints ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceExtendedDynamicStateFeaturesEXT { using NativeType = VkPhysicalDeviceExtendedDynamicStateFeaturesEXT; @@ -51326,27 +48303,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, extendedDynamicState ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedDynamicState == rhs.extendedDynamicState ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51371,26 +48358,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceExtendedDynamicStateFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT const & - physicalDeviceExtendedDynamicStateFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExtendedDynamicStateFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExtendedDynamicStateFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExtendedDynamicStateFeaturesEXT.extendedDynamicState ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceExternalBufferInfo { using NativeType = VkPhysicalDeviceExternalBufferInfo; @@ -51455,28 +48422,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceExternalBufferInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceExternalBufferInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceExternalBufferInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceExternalBufferInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, usage, handleType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExternalBufferInfo const & ) const = default; #else bool operator==( PhysicalDeviceExternalBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( usage == rhs.usage ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceExternalBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51504,28 +48484,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo const & physicalDeviceExternalBufferInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalBufferInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceExternalBufferInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferCreateFlags, seed, physicalDeviceExternalBufferInfo.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BufferUsageFlags, seed, physicalDeviceExternalBufferInfo.usage ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, physicalDeviceExternalBufferInfo.handleType ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceExternalFenceInfo { using NativeType = VkPhysicalDeviceExternalFenceInfo; @@ -51572,27 +48530,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceExternalFenceInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceExternalFenceInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceExternalFenceInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceExternalFenceInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExternalFenceInfo const & ) const = default; #else bool operator==( PhysicalDeviceExternalFenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceExternalFenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51618,26 +48588,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo const & physicalDeviceExternalFenceInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalFenceInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceExternalFenceInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits, seed, physicalDeviceExternalFenceInfo.handleType ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceExternalImageFormatInfo { using NativeType = VkPhysicalDeviceExternalImageFormatInfo; @@ -51687,27 +48637,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceExternalImageFormatInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceExternalImageFormatInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceExternalImageFormatInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceExternalImageFormatInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExternalImageFormatInfo const & ) const = default; #else bool operator==( PhysicalDeviceExternalImageFormatInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceExternalImageFormatInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51733,25 +48695,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo const & - physicalDeviceExternalImageFormatInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalImageFormatInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceExternalImageFormatInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits, seed, physicalDeviceExternalImageFormatInfo.handleType ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceExternalMemoryHostPropertiesEXT { using NativeType = VkPhysicalDeviceExternalMemoryHostPropertiesEXT; @@ -51786,28 +48729,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minImportedHostPointerAlignment ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExternalMemoryHostPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( minImportedHostPointerAlignment == rhs.minImportedHostPointerAlignment ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51832,27 +48784,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceExternalMemoryHostPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT const & - physicalDeviceExternalMemoryHostPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalMemoryHostPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExternalMemoryHostPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, - seed, - physicalDeviceExternalMemoryHostPropertiesEXT.minImportedHostPointerAlignment ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceExternalMemoryRDMAFeaturesNV { using NativeType = VkPhysicalDeviceExternalMemoryRDMAFeaturesNV; @@ -51902,27 +48833,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, externalMemoryRDMA ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryRDMA == rhs.externalMemoryRDMA ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51947,26 +48888,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceExternalMemoryRDMAFeaturesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV const & - physicalDeviceExternalMemoryRDMAFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalMemoryRDMAFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceExternalMemoryRDMAFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceExternalMemoryRDMAFeaturesNV.externalMemoryRDMA ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceExternalSemaphoreInfo { using NativeType = VkPhysicalDeviceExternalSemaphoreInfo; @@ -52015,27 +48936,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceExternalSemaphoreInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceExternalSemaphoreInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceExternalSemaphoreInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceExternalSemaphoreInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExternalSemaphoreInfo const & ) const = default; #else bool operator==( PhysicalDeviceExternalSemaphoreInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceExternalSemaphoreInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -52061,25 +48994,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo const & - physicalDeviceExternalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceExternalSemaphoreInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceExternalSemaphoreInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, physicalDeviceExternalSemaphoreInfo.handleType ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceFeatures2 { using NativeType = VkPhysicalDeviceFeatures2; @@ -52123,27 +49037,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceFeatures2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFeatures2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceFeatures2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFeatures2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, features ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFeatures2 const & ) const = default; #else bool operator==( PhysicalDeviceFeatures2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( features == rhs.features ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFeatures2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -52167,24 +49093,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 const & physicalDeviceFeatures2 ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFeatures2.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFeatures2.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures, seed, physicalDeviceFeatures2.features ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceFloatControlsProperties { using NativeType = VkPhysicalDeviceFloatControlsProperties; @@ -52252,44 +49160,73 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceFloatControlsProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFloatControlsProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceFloatControlsProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFloatControlsProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + denormBehaviorIndependence, + roundingModeIndependence, + shaderSignedZeroInfNanPreserveFloat16, + shaderSignedZeroInfNanPreserveFloat32, + shaderSignedZeroInfNanPreserveFloat64, + shaderDenormPreserveFloat16, + shaderDenormPreserveFloat32, + shaderDenormPreserveFloat64, + shaderDenormFlushToZeroFloat16, + shaderDenormFlushToZeroFloat32, + shaderDenormFlushToZeroFloat64, + shaderRoundingModeRTEFloat16, + shaderRoundingModeRTEFloat32, + shaderRoundingModeRTEFloat64, + shaderRoundingModeRTZFloat16, + shaderRoundingModeRTZFloat32, + shaderRoundingModeRTZFloat64 ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFloatControlsProperties const & ) const = default; #else bool operator==( PhysicalDeviceFloatControlsProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( denormBehaviorIndependence == rhs.denormBehaviorIndependence ) && - ( roundingModeIndependence == rhs.roundingModeIndependence ) && - ( shaderSignedZeroInfNanPreserveFloat16 == rhs.shaderSignedZeroInfNanPreserveFloat16 ) && - ( shaderSignedZeroInfNanPreserveFloat32 == rhs.shaderSignedZeroInfNanPreserveFloat32 ) && - ( shaderSignedZeroInfNanPreserveFloat64 == rhs.shaderSignedZeroInfNanPreserveFloat64 ) && - ( shaderDenormPreserveFloat16 == rhs.shaderDenormPreserveFloat16 ) && - ( shaderDenormPreserveFloat32 == rhs.shaderDenormPreserveFloat32 ) && - ( shaderDenormPreserveFloat64 == rhs.shaderDenormPreserveFloat64 ) && - ( shaderDenormFlushToZeroFloat16 == rhs.shaderDenormFlushToZeroFloat16 ) && - ( shaderDenormFlushToZeroFloat32 == rhs.shaderDenormFlushToZeroFloat32 ) && - ( shaderDenormFlushToZeroFloat64 == rhs.shaderDenormFlushToZeroFloat64 ) && - ( shaderRoundingModeRTEFloat16 == rhs.shaderRoundingModeRTEFloat16 ) && - ( shaderRoundingModeRTEFloat32 == rhs.shaderRoundingModeRTEFloat32 ) && - ( shaderRoundingModeRTEFloat64 == rhs.shaderRoundingModeRTEFloat64 ) && - ( shaderRoundingModeRTZFloat16 == rhs.shaderRoundingModeRTZFloat16 ) && - ( shaderRoundingModeRTZFloat32 == rhs.shaderRoundingModeRTZFloat32 ) && - ( shaderRoundingModeRTZFloat64 == rhs.shaderRoundingModeRTZFloat64 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFloatControlsProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -52332,59 +49269,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties const & - physicalDeviceFloatControlsProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFloatControlsProperties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFloatControlsProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence, - seed, - physicalDeviceFloatControlsProperties.denormBehaviorIndependence ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence, - seed, - physicalDeviceFloatControlsProperties.roundingModeIndependence ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat16 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat32 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat64 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat16 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat32 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat64 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat16 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat32 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat64 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat16 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat32 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat64 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat16 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat32 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat64 ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceFragmentDensityMap2FeaturesEXT { using NativeType = VkPhysicalDeviceFragmentDensityMap2FeaturesEXT; @@ -52434,28 +49318,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentDensityMapDeferred ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( fragmentDensityMapDeferred == rhs.fragmentDensityMapDeferred ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -52480,26 +49373,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceFragmentDensityMap2FeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT const & - physicalDeviceFragmentDensityMap2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentDensityMap2FeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentDensityMap2FeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMap2FeaturesEXT.fragmentDensityMapDeferred ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceFragmentDensityMap2PropertiesEXT { using NativeType = VkPhysicalDeviceFragmentDensityMap2PropertiesEXT; @@ -52540,30 +49413,47 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + subsampledLoads, + subsampledCoarseReconstructionEarlyAccess, + maxSubsampledArrayLayers, + maxDescriptorSetSubsampledSamplers ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subsampledLoads == rhs.subsampledLoads ) && - ( subsampledCoarseReconstructionEarlyAccess == rhs.subsampledCoarseReconstructionEarlyAccess ) && - ( maxSubsampledArrayLayers == rhs.maxSubsampledArrayLayers ) && - ( maxDescriptorSetSubsampledSamplers == rhs.maxDescriptorSetSubsampledSamplers ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -52591,32 +49481,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceFragmentDensityMap2PropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT const & - physicalDeviceFragmentDensityMap2PropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledLoads ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledCoarseReconstructionEarlyAccess ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxSubsampledArrayLayers ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxDescriptorSetSubsampledSamplers ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceFragmentDensityMapFeaturesEXT { using NativeType = VkPhysicalDeviceFragmentDensityMapFeaturesEXT; @@ -52684,29 +49548,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, fragmentDensityMap, fragmentDensityMapDynamic, fragmentDensityMapNonSubsampledImages ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentDensityMapFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMap == rhs.fragmentDensityMap ) && - ( fragmentDensityMapDynamic == rhs.fragmentDensityMapDynamic ) && - ( fragmentDensityMapNonSubsampledImages == rhs.fragmentDensityMapNonSubsampledImages ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -52733,31 +49610,202 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceFragmentDensityMapFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE + struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM + { + using NativeType = VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT const & - physicalDeviceFragmentDensityMapFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentDensityMapFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentDensityMapFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMap ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapDynamic ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapNonSubsampledImages ); - return seed; - } -}; + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM( + VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapOffset_ = {} ) VULKAN_HPP_NOEXCEPT + : fragmentDensityMapOffset( fragmentDensityMapOffset_ ) + {} + + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM( + PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM( + VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM( + *reinterpret_cast( &rhs ) ) + {} +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM & + operator=( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM & + operator=( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = + *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM & + setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM & + setFragmentDensityMapOffset( VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapOffset_ ) VULKAN_HPP_NOEXCEPT + { + fragmentDensityMapOffset = fragmentDensityMapOffset_; + return *this; + } +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + explicit operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + explicit operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentDensityMapOffset ); + } + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return this->reflect() == rhs.reflect(); + } + + bool operator!=( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return this->reflect() != rhs.reflect(); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapOffset = {}; + }; + VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM ) == + sizeof( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM ), + "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, + "PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM is not nothrow_move_constructible!" ); + + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; + }; + + struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM + { + using NativeType = VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM( + VULKAN_HPP_NAMESPACE::Extent2D fragmentDensityOffsetGranularity_ = {} ) VULKAN_HPP_NOEXCEPT + : fragmentDensityOffsetGranularity( fragmentDensityOffsetGranularity_ ) + {} + + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM( + PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM( + VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM( + *reinterpret_cast( &rhs ) ) + {} +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM & + operator=( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM & + operator=( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = + *reinterpret_cast( &rhs ); + return *this; + } + + explicit operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + explicit operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentDensityOffsetGranularity ); + } + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return this->reflect() == rhs.reflect(); + } + + bool operator!=( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return this->reflect() != rhs.reflect(); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Extent2D fragmentDensityOffsetGranularity = {}; + }; + VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM ) == + sizeof( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM ), + "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< + VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>::value, + "PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM is not nothrow_move_constructible!" ); + + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; + }; -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceFragmentDensityMapPropertiesEXT { using NativeType = VkPhysicalDeviceFragmentDensityMapPropertiesEXT; @@ -52796,30 +49844,42 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, minFragmentDensityTexelSize, maxFragmentDensityTexelSize, fragmentDensityInvocations ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentDensityMapPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( minFragmentDensityTexelSize == rhs.minFragmentDensityTexelSize ) && - ( maxFragmentDensityTexelSize == rhs.maxFragmentDensityTexelSize ) && - ( fragmentDensityInvocations == rhs.fragmentDensityInvocations ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -52846,30 +49906,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceFragmentDensityMapPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT const & - physicalDeviceFragmentDensityMapPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentDensityMapPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentDensityMapPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceFragmentDensityMapPropertiesEXT.minFragmentDensityTexelSize ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceFragmentDensityMapPropertiesEXT.maxFragmentDensityTexelSize ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentDensityMapPropertiesEXT.fragmentDensityInvocations ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV { using NativeType = VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV; @@ -52921,28 +49957,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentShaderBarycentric ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( fragmentShaderBarycentric == rhs.fragmentShaderBarycentric ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -52967,26 +50012,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceFragmentShaderBarycentricFeaturesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & - physicalDeviceFragmentShaderBarycentricFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShaderBarycentricFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShaderBarycentricFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShaderBarycentricFeaturesNV.fragmentShaderBarycentric ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT { using NativeType = VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT; @@ -53055,30 +50080,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, fragmentShaderSampleInterlock, fragmentShaderPixelInterlock, fragmentShaderShadingRateInterlock ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( fragmentShaderSampleInterlock == rhs.fragmentShaderSampleInterlock ) && - ( fragmentShaderPixelInterlock == rhs.fragmentShaderPixelInterlock ) && - ( fragmentShaderShadingRateInterlock == rhs.fragmentShaderShadingRateInterlock ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -53105,33 +50142,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceFragmentShaderInterlockFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & - physicalDeviceFragmentShaderInterlockFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderSampleInterlock ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderPixelInterlock ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderShadingRateInterlock ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { using NativeType = VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV; @@ -53200,30 +50210,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, fragmentShadingRateEnums, supersampleFragmentShadingRates, noInvocationFragmentShadingRates ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( fragmentShadingRateEnums == rhs.fragmentShadingRateEnums ) && - ( supersampleFragmentShadingRates == rhs.supersampleFragmentShadingRates ) && - ( noInvocationFragmentShadingRates == rhs.noInvocationFragmentShadingRates ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -53250,32 +50272,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceFragmentShadingRateEnumsFeaturesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & - physicalDeviceFragmentShadingRateEnumsFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.fragmentShadingRateEnums ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceFragmentShadingRateEnumsFeaturesNV.supersampleFragmentShadingRates ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceFragmentShadingRateEnumsFeaturesNV.noInvocationFragmentShadingRates ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { using NativeType = VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV; @@ -53329,28 +50325,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxFragmentShadingRateInvocationCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxFragmentShadingRateInvocationCount == rhs.maxFragmentShadingRateInvocationCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -53376,27 +50383,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceFragmentShadingRateEnumsPropertiesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & - physicalDeviceFragmentShadingRateEnumsPropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlagBits, - seed, - physicalDeviceFragmentShadingRateEnumsPropertiesNV.maxFragmentShadingRateInvocationCount ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceFragmentShadingRateFeaturesKHR { using NativeType = VkPhysicalDeviceFragmentShadingRateFeaturesKHR; @@ -53464,30 +50450,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, pipelineFragmentShadingRate, primitiveFragmentShadingRate, attachmentFragmentShadingRate ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShadingRateFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( pipelineFragmentShadingRate == rhs.pipelineFragmentShadingRate ) && - ( primitiveFragmentShadingRate == rhs.primitiveFragmentShadingRate ) && - ( attachmentFragmentShadingRate == rhs.attachmentFragmentShadingRate ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -53514,30 +50512,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceFragmentShadingRateFeaturesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR const & - physicalDeviceFragmentShadingRateFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRateFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRateFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShadingRateFeaturesKHR.pipelineFragmentShadingRate ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShadingRateFeaturesKHR.primitiveFragmentShadingRate ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceFragmentShadingRateFeaturesKHR.attachmentFragmentShadingRate ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceFragmentShadingRateKHR { using NativeType = VkPhysicalDeviceFragmentShadingRateKHR; @@ -53572,28 +50546,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceFragmentShadingRateKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentShadingRateKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceFragmentShadingRateKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentShadingRateKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, sampleCounts, fragmentSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShadingRateKHR const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShadingRateKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleCounts == rhs.sampleCounts ) && - ( fragmentSize == rhs.fragmentSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentShadingRateKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -53618,26 +50604,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceFragmentShadingRateKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR const & - physicalDeviceFragmentShadingRateKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRateKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRateKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceFragmentShadingRateKHR.sampleCounts ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceFragmentShadingRateKHR.fragmentSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceFragmentShadingRatePropertiesKHR { using NativeType = VkPhysicalDeviceFragmentShadingRatePropertiesKHR; @@ -53705,48 +50671,73 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + minFragmentShadingRateAttachmentTexelSize, + maxFragmentShadingRateAttachmentTexelSize, + maxFragmentShadingRateAttachmentTexelSizeAspectRatio, + primitiveFragmentShadingRateWithMultipleViewports, + layeredShadingRateAttachments, + fragmentShadingRateNonTrivialCombinerOps, + maxFragmentSize, + maxFragmentSizeAspectRatio, + maxFragmentShadingRateCoverageSamples, + maxFragmentShadingRateRasterizationSamples, + fragmentShadingRateWithShaderDepthStencilWrites, + fragmentShadingRateWithSampleMask, + fragmentShadingRateWithShaderSampleMask, + fragmentShadingRateWithConservativeRasterization, + fragmentShadingRateWithFragmentShaderInterlock, + fragmentShadingRateWithCustomSampleLocations, + fragmentShadingRateStrictMultiplyCombiner ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShadingRatePropertiesKHR const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( minFragmentShadingRateAttachmentTexelSize == rhs.minFragmentShadingRateAttachmentTexelSize ) && - ( maxFragmentShadingRateAttachmentTexelSize == rhs.maxFragmentShadingRateAttachmentTexelSize ) && - ( maxFragmentShadingRateAttachmentTexelSizeAspectRatio == - rhs.maxFragmentShadingRateAttachmentTexelSizeAspectRatio ) && - ( primitiveFragmentShadingRateWithMultipleViewports == - rhs.primitiveFragmentShadingRateWithMultipleViewports ) && - ( layeredShadingRateAttachments == rhs.layeredShadingRateAttachments ) && - ( fragmentShadingRateNonTrivialCombinerOps == rhs.fragmentShadingRateNonTrivialCombinerOps ) && - ( maxFragmentSize == rhs.maxFragmentSize ) && - ( maxFragmentSizeAspectRatio == rhs.maxFragmentSizeAspectRatio ) && - ( maxFragmentShadingRateCoverageSamples == rhs.maxFragmentShadingRateCoverageSamples ) && - ( maxFragmentShadingRateRasterizationSamples == rhs.maxFragmentShadingRateRasterizationSamples ) && - ( fragmentShadingRateWithShaderDepthStencilWrites == - rhs.fragmentShadingRateWithShaderDepthStencilWrites ) && - ( fragmentShadingRateWithSampleMask == rhs.fragmentShadingRateWithSampleMask ) && - ( fragmentShadingRateWithShaderSampleMask == rhs.fragmentShadingRateWithShaderSampleMask ) && - ( fragmentShadingRateWithConservativeRasterization == - rhs.fragmentShadingRateWithConservativeRasterization ) && - ( fragmentShadingRateWithFragmentShaderInterlock == rhs.fragmentShadingRateWithFragmentShaderInterlock ) && - ( fragmentShadingRateWithCustomSampleLocations == rhs.fragmentShadingRateWithCustomSampleLocations ) && - ( fragmentShadingRateStrictMultiplyCombiner == rhs.fragmentShadingRateStrictMultiplyCombiner ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -53788,79 +50779,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceFragmentShadingRatePropertiesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR const & - physicalDeviceFragmentShadingRatePropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceFragmentShadingRatePropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceFragmentShadingRatePropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, - seed, - physicalDeviceFragmentShadingRatePropertiesKHR.minFragmentShadingRateAttachmentTexelSize ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, - seed, - physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSize ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, - seed, - physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSizeAspectRatio ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceFragmentShadingRatePropertiesKHR.primitiveFragmentShadingRateWithMultipleViewports ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceFragmentShadingRatePropertiesKHR.layeredShadingRateAttachments ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateNonTrivialCombinerOps ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSize ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSizeAspectRatio ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateCoverageSamples ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlagBits, - seed, - physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateRasterizationSamples ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderDepthStencilWrites ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithSampleMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderSampleMask ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithConservativeRasterization ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithFragmentShaderInterlock ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithCustomSampleLocations ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateStrictMultiplyCombiner ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceGlobalPriorityQueryFeaturesEXT { using NativeType = VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT; @@ -53910,27 +50828,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, globalPriorityQuery ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriorityQuery == rhs.globalPriorityQuery ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -53955,26 +50883,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceGlobalPriorityQueryFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & - physicalDeviceGlobalPriorityQueryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceGlobalPriorityQueryFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceGlobalPriorityQueryFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceGlobalPriorityQueryFeaturesEXT.globalPriorityQuery ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceGroupProperties { using NativeType = VkPhysicalDeviceGroupProperties; @@ -54009,28 +50917,42 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceGroupProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceGroupProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceGroupProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceGroupProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple< + VULKAN_HPP_NAMESPACE::StructureType const &, + void * const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::Bool32 const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, physicalDeviceCount, physicalDevices, subsetAllocation ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceGroupProperties const & ) const = default; #else bool operator==( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) && - ( physicalDevices == rhs.physicalDevices ) && ( subsetAllocation == rhs.subsetAllocation ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -54058,30 +50980,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties const & physicalDeviceGroupProperties ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceGroupProperties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceGroupProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceGroupProperties.physicalDeviceCount ); - for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PhysicalDevice, seed, physicalDeviceGroupProperties.physicalDevices[i] ); - } - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceGroupProperties.subsetAllocation ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceHostQueryResetFeatures { using NativeType = VkPhysicalDeviceHostQueryResetFeatures; @@ -54129,27 +51027,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceHostQueryResetFeatures const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceHostQueryResetFeatures const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceHostQueryResetFeatures &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceHostQueryResetFeatures &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, hostQueryReset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceHostQueryResetFeatures const & ) const = default; #else bool operator==( PhysicalDeviceHostQueryResetFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hostQueryReset == rhs.hostQueryReset ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceHostQueryResetFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -54174,24 +51082,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures const & - physicalDeviceHostQueryResetFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceHostQueryResetFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceHostQueryResetFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceHostQueryResetFeatures.hostQueryReset ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceIDProperties { using NativeType = VkPhysicalDeviceIDProperties; @@ -54229,29 +51119,43 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceIDProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceIDProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceIDProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceIDProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::Bool32 const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceUUID, driverUUID, deviceLUID, deviceNodeMask, deviceLUIDValid ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceIDProperties const & ) const = default; #else bool operator==( PhysicalDeviceIDProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceUUID == rhs.deviceUUID ) && - ( driverUUID == rhs.driverUUID ) && ( deviceLUID == rhs.deviceLUID ) && - ( deviceNodeMask == rhs.deviceNodeMask ) && ( deviceLUIDValid == rhs.deviceLUIDValid ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceIDProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -54279,37 +51183,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties const & physicalDeviceIDProperties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceIDProperties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceIDProperties.pNext ); - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceIDProperties.deviceUUID[i] ); - } - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceIDProperties.driverUUID[i] ); - } - for ( size_t i = 0; i < VK_LUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceIDProperties.deviceLUID[i] ); - } - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceIDProperties.deviceNodeMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceIDProperties.deviceLUIDValid ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceImageDrmFormatModifierInfoEXT { using NativeType = VkPhysicalDeviceImageDrmFormatModifierInfoEXT; @@ -54409,29 +51282,42 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, drmFormatModifier, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceImageDrmFormatModifierInfoEXT const & ) const = default; #else bool operator==( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ) && - ( sharingMode == rhs.sharingMode ) && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && - ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -54459,29 +51345,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceImageDrmFormatModifierInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT const & - physicalDeviceImageDrmFormatModifierInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageDrmFormatModifierInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceImageDrmFormatModifierInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceImageDrmFormatModifierInfoEXT.drmFormatModifier ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SharingMode, seed, physicalDeviceImageDrmFormatModifierInfoEXT.sharingMode ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceImageDrmFormatModifierInfoEXT.queueFamilyIndexCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, physicalDeviceImageDrmFormatModifierInfoEXT.pQueueFamilyIndices ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceImageFormatInfo2 { using NativeType = VkPhysicalDeviceImageFormatInfo2; @@ -54563,28 +51426,43 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceImageFormatInfo2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceImageFormatInfo2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceImageFormatInfo2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceImageFormatInfo2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, format, type, tiling, usage, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceImageFormatInfo2 const & ) const = default; #else bool operator==( PhysicalDeviceImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( type == rhs.type ) && - ( tiling == rhs.tiling ) && ( usage == rhs.usage ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -54613,28 +51491,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 const & physicalDeviceImageFormatInfo2 ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageFormatInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceImageFormatInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, physicalDeviceImageFormatInfo2.format ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageType, seed, physicalDeviceImageFormatInfo2.type ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageTiling, seed, physicalDeviceImageFormatInfo2.tiling ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, physicalDeviceImageFormatInfo2.usage ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageCreateFlags, seed, physicalDeviceImageFormatInfo2.flags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceImageRobustnessFeaturesEXT { using NativeType = VkPhysicalDeviceImageRobustnessFeaturesEXT; @@ -54684,27 +51540,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceImageRobustnessFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceImageRobustnessFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceImageRobustnessFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceImageRobustnessFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, robustImageAccess ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceImageRobustnessFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustImageAccess == rhs.robustImageAccess ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -54729,26 +51595,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceImageRobustnessFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeaturesEXT const & - physicalDeviceImageRobustnessFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageRobustnessFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceImageRobustnessFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceImageRobustnessFeaturesEXT.robustImageAccess ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceImageViewImageFormatInfoEXT { using NativeType = VkPhysicalDeviceImageViewImageFormatInfoEXT; @@ -54799,27 +51645,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceImageViewImageFormatInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceImageViewImageFormatInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceImageViewImageFormatInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceImageViewImageFormatInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageViewType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceImageViewImageFormatInfoEXT const & ) const = default; #else bool operator==( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageViewType == rhs.imageViewType ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -54844,26 +51700,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceImageViewImageFormatInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT const & - physicalDeviceImageViewImageFormatInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageViewImageFormatInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceImageViewImageFormatInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ImageViewType, seed, physicalDeviceImageViewImageFormatInfoEXT.imageViewType ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceImageViewMinLodFeaturesEXT { using NativeType = VkPhysicalDeviceImageViewMinLodFeaturesEXT; @@ -54913,27 +51749,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceImageViewMinLodFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceImageViewMinLodFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceImageViewMinLodFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceImageViewMinLodFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minLod ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceImageViewMinLodFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minLod == rhs.minLod ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -54958,25 +51804,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceImageViewMinLodFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT const & - physicalDeviceImageViewMinLodFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImageViewMinLodFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceImageViewMinLodFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceImageViewMinLodFeaturesEXT.minLod ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceImagelessFramebufferFeatures { using NativeType = VkPhysicalDeviceImagelessFramebufferFeatures; @@ -55026,27 +51853,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceImagelessFramebufferFeatures const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceImagelessFramebufferFeatures const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceImagelessFramebufferFeatures &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceImagelessFramebufferFeatures &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imagelessFramebuffer ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceImagelessFramebufferFeatures const & ) const = default; #else bool operator==( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imagelessFramebuffer == rhs.imagelessFramebuffer ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -55072,26 +51909,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures const & - physicalDeviceImagelessFramebufferFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceImagelessFramebufferFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceImagelessFramebufferFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceIndexTypeUint8FeaturesEXT { using NativeType = VkPhysicalDeviceIndexTypeUint8FeaturesEXT; @@ -55140,27 +51957,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, indexTypeUint8 ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceIndexTypeUint8FeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indexTypeUint8 == rhs.indexTypeUint8 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -55185,25 +52012,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceIndexTypeUint8FeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT const & - physicalDeviceIndexTypeUint8FeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceIndexTypeUint8FeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceIndexTypeUint8FeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceIndexTypeUint8FeaturesEXT.indexTypeUint8 ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceInheritedViewportScissorFeaturesNV { using NativeType = VkPhysicalDeviceInheritedViewportScissorFeaturesNV; @@ -55254,28 +52062,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, inheritedViewportScissor2D ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceInheritedViewportScissorFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( inheritedViewportScissor2D == rhs.inheritedViewportScissor2D ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -55300,26 +52117,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceInheritedViewportScissorFeaturesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV const & - physicalDeviceInheritedViewportScissorFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceInheritedViewportScissorFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceInheritedViewportScissorFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceInheritedViewportScissorFeaturesNV.inheritedViewportScissor2D ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceInlineUniformBlockFeaturesEXT { using NativeType = VkPhysicalDeviceInlineUniformBlockFeaturesEXT; @@ -55379,29 +52176,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, inlineUniformBlock, descriptorBindingInlineUniformBlockUpdateAfterBind ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceInlineUniformBlockFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( inlineUniformBlock == rhs.inlineUniformBlock ) && - ( descriptorBindingInlineUniformBlockUpdateAfterBind == - rhs.descriptorBindingInlineUniformBlockUpdateAfterBind ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -55427,30 +52235,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceInlineUniformBlockFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeaturesEXT const & - physicalDeviceInlineUniformBlockFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceInlineUniformBlockFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceInlineUniformBlockFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceInlineUniformBlockFeaturesEXT.inlineUniformBlock ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceInlineUniformBlockFeaturesEXT.descriptorBindingInlineUniformBlockUpdateAfterBind ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceInlineUniformBlockPropertiesEXT { using NativeType = VkPhysicalDeviceInlineUniformBlockPropertiesEXT; @@ -55494,34 +52278,49 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxInlineUniformBlockSize, + maxPerStageDescriptorInlineUniformBlocks, + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, + maxDescriptorSetInlineUniformBlocks, + maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceInlineUniformBlockPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxInlineUniformBlockSize == rhs.maxInlineUniformBlockSize ) && - ( maxPerStageDescriptorInlineUniformBlocks == rhs.maxPerStageDescriptorInlineUniformBlocks ) && - ( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks == - rhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ) && - ( maxDescriptorSetInlineUniformBlocks == rhs.maxDescriptorSetInlineUniformBlocks ) && - ( maxDescriptorSetUpdateAfterBindInlineUniformBlocks == - rhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -55550,37 +52349,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceInlineUniformBlockPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockPropertiesEXT const & - physicalDeviceInlineUniformBlockPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceInlineUniformBlockPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceInlineUniformBlockPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceInlineUniformBlockPropertiesEXT.maxInlineUniformBlockSize ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceInlineUniformBlockPropertiesEXT.maxPerStageDescriptorInlineUniformBlocks ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, - seed, - physicalDeviceInlineUniformBlockPropertiesEXT.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceInlineUniformBlockPropertiesEXT.maxDescriptorSetInlineUniformBlocks ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, - seed, - physicalDeviceInlineUniformBlockPropertiesEXT.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceInvocationMaskFeaturesHUAWEI { using NativeType = VkPhysicalDeviceInvocationMaskFeaturesHUAWEI; @@ -55629,27 +52397,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, invocationMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & ) const = default; #else bool operator==( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( invocationMask == rhs.invocationMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -55674,26 +52452,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceInvocationMaskFeaturesHUAWEI; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI const & - physicalDeviceInvocationMaskFeaturesHUAWEI ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceInvocationMaskFeaturesHUAWEI.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceInvocationMaskFeaturesHUAWEI.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceInvocationMaskFeaturesHUAWEI.invocationMask ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceLimits { using NativeType = VkPhysicalDeviceLimits; @@ -55929,125 +52687,247 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceLimits const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceLimits const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceLimits &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceLimits &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + float const &, + float const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + uint32_t const &, + size_t const &, + VULKAN_HPP_NAMESPACE::DeviceSize const &, + VULKAN_HPP_NAMESPACE::DeviceSize const &, + VULKAN_HPP_NAMESPACE::DeviceSize const &, + int32_t const &, + uint32_t const &, + int32_t const &, + uint32_t const &, + float const &, + float const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + float const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + float const &, + float const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::DeviceSize const &, + VULKAN_HPP_NAMESPACE::DeviceSize const &, + VULKAN_HPP_NAMESPACE::DeviceSize const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( maxImageDimension1D, + maxImageDimension2D, + maxImageDimension3D, + maxImageDimensionCube, + maxImageArrayLayers, + maxTexelBufferElements, + maxUniformBufferRange, + maxStorageBufferRange, + maxPushConstantsSize, + maxMemoryAllocationCount, + maxSamplerAllocationCount, + bufferImageGranularity, + sparseAddressSpaceSize, + maxBoundDescriptorSets, + maxPerStageDescriptorSamplers, + maxPerStageDescriptorUniformBuffers, + maxPerStageDescriptorStorageBuffers, + maxPerStageDescriptorSampledImages, + maxPerStageDescriptorStorageImages, + maxPerStageDescriptorInputAttachments, + maxPerStageResources, + maxDescriptorSetSamplers, + maxDescriptorSetUniformBuffers, + maxDescriptorSetUniformBuffersDynamic, + maxDescriptorSetStorageBuffers, + maxDescriptorSetStorageBuffersDynamic, + maxDescriptorSetSampledImages, + maxDescriptorSetStorageImages, + maxDescriptorSetInputAttachments, + maxVertexInputAttributes, + maxVertexInputBindings, + maxVertexInputAttributeOffset, + maxVertexInputBindingStride, + maxVertexOutputComponents, + maxTessellationGenerationLevel, + maxTessellationPatchSize, + maxTessellationControlPerVertexInputComponents, + maxTessellationControlPerVertexOutputComponents, + maxTessellationControlPerPatchOutputComponents, + maxTessellationControlTotalOutputComponents, + maxTessellationEvaluationInputComponents, + maxTessellationEvaluationOutputComponents, + maxGeometryShaderInvocations, + maxGeometryInputComponents, + maxGeometryOutputComponents, + maxGeometryOutputVertices, + maxGeometryTotalOutputComponents, + maxFragmentInputComponents, + maxFragmentOutputAttachments, + maxFragmentDualSrcAttachments, + maxFragmentCombinedOutputResources, + maxComputeSharedMemorySize, + maxComputeWorkGroupCount, + maxComputeWorkGroupInvocations, + maxComputeWorkGroupSize, + subPixelPrecisionBits, + subTexelPrecisionBits, + mipmapPrecisionBits, + maxDrawIndexedIndexValue, + maxDrawIndirectCount, + maxSamplerLodBias, + maxSamplerAnisotropy, + maxViewports, + maxViewportDimensions, + viewportBoundsRange, + viewportSubPixelBits, + minMemoryMapAlignment, + minTexelBufferOffsetAlignment, + minUniformBufferOffsetAlignment, + minStorageBufferOffsetAlignment, + minTexelOffset, + maxTexelOffset, + minTexelGatherOffset, + maxTexelGatherOffset, + minInterpolationOffset, + maxInterpolationOffset, + subPixelInterpolationOffsetBits, + maxFramebufferWidth, + maxFramebufferHeight, + maxFramebufferLayers, + framebufferColorSampleCounts, + framebufferDepthSampleCounts, + framebufferStencilSampleCounts, + framebufferNoAttachmentsSampleCounts, + maxColorAttachments, + sampledImageColorSampleCounts, + sampledImageIntegerSampleCounts, + sampledImageDepthSampleCounts, + sampledImageStencilSampleCounts, + storageImageSampleCounts, + maxSampleMaskWords, + timestampComputeAndGraphics, + timestampPeriod, + maxClipDistances, + maxCullDistances, + maxCombinedClipAndCullDistances, + discreteQueuePriorities, + pointSizeRange, + lineWidthRange, + pointSizeGranularity, + lineWidthGranularity, + strictLines, + standardSampleLocations, + optimalBufferCopyOffsetAlignment, + optimalBufferCopyRowPitchAlignment, + nonCoherentAtomSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceLimits const & ) const = default; #else bool operator==( PhysicalDeviceLimits const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( maxImageDimension1D == rhs.maxImageDimension1D ) && ( maxImageDimension2D == rhs.maxImageDimension2D ) && - ( maxImageDimension3D == rhs.maxImageDimension3D ) && - ( maxImageDimensionCube == rhs.maxImageDimensionCube ) && - ( maxImageArrayLayers == rhs.maxImageArrayLayers ) && - ( maxTexelBufferElements == rhs.maxTexelBufferElements ) && - ( maxUniformBufferRange == rhs.maxUniformBufferRange ) && - ( maxStorageBufferRange == rhs.maxStorageBufferRange ) && - ( maxPushConstantsSize == rhs.maxPushConstantsSize ) && - ( maxMemoryAllocationCount == rhs.maxMemoryAllocationCount ) && - ( maxSamplerAllocationCount == rhs.maxSamplerAllocationCount ) && - ( bufferImageGranularity == rhs.bufferImageGranularity ) && - ( sparseAddressSpaceSize == rhs.sparseAddressSpaceSize ) && - ( maxBoundDescriptorSets == rhs.maxBoundDescriptorSets ) && - ( maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers ) && - ( maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers ) && - ( maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers ) && - ( maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages ) && - ( maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages ) && - ( maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments ) && - ( maxPerStageResources == rhs.maxPerStageResources ) && - ( maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers ) && - ( maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers ) && - ( maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic ) && - ( maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers ) && - ( maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic ) && - ( maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages ) && - ( maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages ) && - ( maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments ) && - ( maxVertexInputAttributes == rhs.maxVertexInputAttributes ) && - ( maxVertexInputBindings == rhs.maxVertexInputBindings ) && - ( maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset ) && - ( maxVertexInputBindingStride == rhs.maxVertexInputBindingStride ) && - ( maxVertexOutputComponents == rhs.maxVertexOutputComponents ) && - ( maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel ) && - ( maxTessellationPatchSize == rhs.maxTessellationPatchSize ) && - ( maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents ) && - ( maxTessellationControlPerVertexOutputComponents == - rhs.maxTessellationControlPerVertexOutputComponents ) && - ( maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents ) && - ( maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents ) && - ( maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents ) && - ( maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents ) && - ( maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations ) && - ( maxGeometryInputComponents == rhs.maxGeometryInputComponents ) && - ( maxGeometryOutputComponents == rhs.maxGeometryOutputComponents ) && - ( maxGeometryOutputVertices == rhs.maxGeometryOutputVertices ) && - ( maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents ) && - ( maxFragmentInputComponents == rhs.maxFragmentInputComponents ) && - ( maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments ) && - ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments ) && - ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources ) && - ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize ) && - ( maxComputeWorkGroupCount == rhs.maxComputeWorkGroupCount ) && - ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations ) && - ( maxComputeWorkGroupSize == rhs.maxComputeWorkGroupSize ) && - ( subPixelPrecisionBits == rhs.subPixelPrecisionBits ) && - ( subTexelPrecisionBits == rhs.subTexelPrecisionBits ) && - ( mipmapPrecisionBits == rhs.mipmapPrecisionBits ) && - ( maxDrawIndexedIndexValue == rhs.maxDrawIndexedIndexValue ) && - ( maxDrawIndirectCount == rhs.maxDrawIndirectCount ) && ( maxSamplerLodBias == rhs.maxSamplerLodBias ) && - ( maxSamplerAnisotropy == rhs.maxSamplerAnisotropy ) && ( maxViewports == rhs.maxViewports ) && - ( maxViewportDimensions == rhs.maxViewportDimensions ) && - ( viewportBoundsRange == rhs.viewportBoundsRange ) && - ( viewportSubPixelBits == rhs.viewportSubPixelBits ) && - ( minMemoryMapAlignment == rhs.minMemoryMapAlignment ) && - ( minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment ) && - ( minUniformBufferOffsetAlignment == rhs.minUniformBufferOffsetAlignment ) && - ( minStorageBufferOffsetAlignment == rhs.minStorageBufferOffsetAlignment ) && - ( minTexelOffset == rhs.minTexelOffset ) && ( maxTexelOffset == rhs.maxTexelOffset ) && - ( minTexelGatherOffset == rhs.minTexelGatherOffset ) && - ( maxTexelGatherOffset == rhs.maxTexelGatherOffset ) && - ( minInterpolationOffset == rhs.minInterpolationOffset ) && - ( maxInterpolationOffset == rhs.maxInterpolationOffset ) && - ( subPixelInterpolationOffsetBits == rhs.subPixelInterpolationOffsetBits ) && - ( maxFramebufferWidth == rhs.maxFramebufferWidth ) && - ( maxFramebufferHeight == rhs.maxFramebufferHeight ) && - ( maxFramebufferLayers == rhs.maxFramebufferLayers ) && - ( framebufferColorSampleCounts == rhs.framebufferColorSampleCounts ) && - ( framebufferDepthSampleCounts == rhs.framebufferDepthSampleCounts ) && - ( framebufferStencilSampleCounts == rhs.framebufferStencilSampleCounts ) && - ( framebufferNoAttachmentsSampleCounts == rhs.framebufferNoAttachmentsSampleCounts ) && - ( maxColorAttachments == rhs.maxColorAttachments ) && - ( sampledImageColorSampleCounts == rhs.sampledImageColorSampleCounts ) && - ( sampledImageIntegerSampleCounts == rhs.sampledImageIntegerSampleCounts ) && - ( sampledImageDepthSampleCounts == rhs.sampledImageDepthSampleCounts ) && - ( sampledImageStencilSampleCounts == rhs.sampledImageStencilSampleCounts ) && - ( storageImageSampleCounts == rhs.storageImageSampleCounts ) && - ( maxSampleMaskWords == rhs.maxSampleMaskWords ) && - ( timestampComputeAndGraphics == rhs.timestampComputeAndGraphics ) && - ( timestampPeriod == rhs.timestampPeriod ) && ( maxClipDistances == rhs.maxClipDistances ) && - ( maxCullDistances == rhs.maxCullDistances ) && - ( maxCombinedClipAndCullDistances == rhs.maxCombinedClipAndCullDistances ) && - ( discreteQueuePriorities == rhs.discreteQueuePriorities ) && ( pointSizeRange == rhs.pointSizeRange ) && - ( lineWidthRange == rhs.lineWidthRange ) && ( pointSizeGranularity == rhs.pointSizeGranularity ) && - ( lineWidthGranularity == rhs.lineWidthGranularity ) && ( strictLines == rhs.strictLines ) && - ( standardSampleLocations == rhs.standardSampleLocations ) && - ( optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment ) && - ( optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment ) && - ( nonCoherentAtomSize == rhs.nonCoherentAtomSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceLimits const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -56166,159 +53046,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "PhysicalDeviceLimits is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const & physicalDeviceLimits ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageDimension1D ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageDimension2D ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageDimension3D ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageDimensionCube ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxImageArrayLayers ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTexelBufferElements ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxUniformBufferRange ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxStorageBufferRange ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPushConstantsSize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxMemoryAllocationCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxSamplerAllocationCount ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.bufferImageGranularity ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.sparseAddressSpaceSize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxBoundDescriptorSets ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorSamplers ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorUniformBuffers ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorStorageBuffers ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorSampledImages ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorStorageImages ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageDescriptorInputAttachments ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxPerStageResources ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetSamplers ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetUniformBuffers ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetUniformBuffersDynamic ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetStorageBuffers ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetStorageBuffersDynamic ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetSampledImages ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetStorageImages ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDescriptorSetInputAttachments ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexInputAttributes ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexInputBindings ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexInputAttributeOffset ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexInputBindingStride ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxVertexOutputComponents ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationGenerationLevel ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationPatchSize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationControlPerVertexInputComponents ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationControlPerVertexOutputComponents ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationControlPerPatchOutputComponents ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationControlTotalOutputComponents ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationEvaluationInputComponents ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTessellationEvaluationOutputComponents ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryShaderInvocations ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryInputComponents ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryOutputComponents ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryOutputVertices ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxGeometryTotalOutputComponents ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFragmentInputComponents ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFragmentOutputAttachments ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFragmentDualSrcAttachments ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFragmentCombinedOutputResources ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxComputeSharedMemorySize ); - for ( size_t i = 0; i < 3; ++i ) - { - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxComputeWorkGroupCount[i] ); - } - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxComputeWorkGroupInvocations ); - for ( size_t i = 0; i < 3; ++i ) - { - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxComputeWorkGroupSize[i] ); - } - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.subPixelPrecisionBits ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.subTexelPrecisionBits ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.mipmapPrecisionBits ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDrawIndexedIndexValue ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxDrawIndirectCount ); - VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.maxSamplerLodBias ); - VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.maxSamplerAnisotropy ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxViewports ); - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxViewportDimensions[i] ); - } - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.viewportBoundsRange[i] ); - } - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.viewportSubPixelBits ); - VULKAN_HPP_HASH_COMBINE( size_t, seed, physicalDeviceLimits.minMemoryMapAlignment ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.minTexelBufferOffsetAlignment ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.minUniformBufferOffsetAlignment ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.minStorageBufferOffsetAlignment ); - VULKAN_HPP_HASH_COMBINE( int32_t, seed, physicalDeviceLimits.minTexelOffset ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTexelOffset ); - VULKAN_HPP_HASH_COMBINE( int32_t, seed, physicalDeviceLimits.minTexelGatherOffset ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxTexelGatherOffset ); - VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.minInterpolationOffset ); - VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.maxInterpolationOffset ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.subPixelInterpolationOffsetBits ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFramebufferWidth ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFramebufferHeight ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxFramebufferLayers ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.framebufferColorSampleCounts ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.framebufferDepthSampleCounts ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.framebufferStencilSampleCounts ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.framebufferNoAttachmentsSampleCounts ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxColorAttachments ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.sampledImageColorSampleCounts ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.sampledImageIntegerSampleCounts ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.sampledImageDepthSampleCounts ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.sampledImageStencilSampleCounts ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlags, seed, physicalDeviceLimits.storageImageSampleCounts ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxSampleMaskWords ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLimits.timestampComputeAndGraphics ); - VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.timestampPeriod ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxClipDistances ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxCullDistances ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.maxCombinedClipAndCullDistances ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLimits.discreteQueuePriorities ); - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.pointSizeRange[i] ); - } - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.lineWidthRange[i] ); - } - VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.pointSizeGranularity ); - VULKAN_HPP_HASH_COMBINE( float, seed, physicalDeviceLimits.lineWidthGranularity ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLimits.strictLines ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLimits.standardSampleLocations ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.optimalBufferCopyOffsetAlignment ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.optimalBufferCopyRowPitchAlignment ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceLimits.nonCoherentAtomSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceLineRasterizationFeaturesEXT { using NativeType = VkPhysicalDeviceLineRasterizationFeaturesEXT; @@ -56413,31 +53140,51 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceLineRasterizationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceLineRasterizationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceLineRasterizationFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceLineRasterizationFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + rectangularLines, + bresenhamLines, + smoothLines, + stippledRectangularLines, + stippledBresenhamLines, + stippledSmoothLines ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceLineRasterizationFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rectangularLines == rhs.rectangularLines ) && - ( bresenhamLines == rhs.bresenhamLines ) && ( smoothLines == rhs.smoothLines ) && - ( stippledRectangularLines == rhs.stippledRectangularLines ) && - ( stippledBresenhamLines == rhs.stippledBresenhamLines ) && - ( stippledSmoothLines == rhs.stippledSmoothLines ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -56467,36 +53214,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceLineRasterizationFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT const & - physicalDeviceLineRasterizationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceLineRasterizationFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceLineRasterizationFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.rectangularLines ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.bresenhamLines ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.smoothLines ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.stippledRectangularLines ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.stippledBresenhamLines ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceLineRasterizationFeaturesEXT.stippledSmoothLines ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceLineRasterizationPropertiesEXT { using NativeType = VkPhysicalDeviceLineRasterizationPropertiesEXT; @@ -56531,28 +53248,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceLineRasterizationPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceLineRasterizationPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceLineRasterizationPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceLineRasterizationPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, lineSubPixelPrecisionBits ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceLineRasterizationPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( lineSubPixelPrecisionBits == rhs.lineSubPixelPrecisionBits ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -56577,25 +53303,111 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceLineRasterizationPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE + struct PhysicalDeviceLinearColorAttachmentFeaturesNV + { + using NativeType = VkPhysicalDeviceLinearColorAttachmentFeaturesNV; -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT const & - physicalDeviceLineRasterizationPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceLineRasterizationPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceLineRasterizationPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceLineRasterizationPropertiesEXT.lineSubPixelPrecisionBits ); - return seed; - } -}; + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceLinearColorAttachmentFeaturesNV( + VULKAN_HPP_NAMESPACE::Bool32 linearColorAttachment_ = {} ) VULKAN_HPP_NOEXCEPT + : linearColorAttachment( linearColorAttachment_ ) + {} + + VULKAN_HPP_CONSTEXPR PhysicalDeviceLinearColorAttachmentFeaturesNV( + PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceLinearColorAttachmentFeaturesNV( VkPhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) + VULKAN_HPP_NOEXCEPT + : PhysicalDeviceLinearColorAttachmentFeaturesNV( + *reinterpret_cast( &rhs ) ) + {} +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + PhysicalDeviceLinearColorAttachmentFeaturesNV & + operator=( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceLinearColorAttachmentFeaturesNV & + operator=( VkPhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLinearColorAttachmentFeaturesNV & + setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLinearColorAttachmentFeaturesNV & + setLinearColorAttachment( VULKAN_HPP_NAMESPACE::Bool32 linearColorAttachment_ ) VULKAN_HPP_NOEXCEPT + { + linearColorAttachment = linearColorAttachment_; + return *this; + } +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + explicit operator VkPhysicalDeviceLinearColorAttachmentFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + explicit operator VkPhysicalDeviceLinearColorAttachmentFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, linearColorAttachment ); + } + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceLinearColorAttachmentFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return this->reflect() == rhs.reflect(); + } + + bool operator!=( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return this->reflect() != rhs.reflect(); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 linearColorAttachment = {}; + }; + VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV ) == + sizeof( VkPhysicalDeviceLinearColorAttachmentFeaturesNV ), + "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, + "PhysicalDeviceLinearColorAttachmentFeaturesNV is not nothrow_move_constructible!" ); + + template <> + struct CppType + { + using Type = PhysicalDeviceLinearColorAttachmentFeaturesNV; + }; -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceMaintenance3Properties { using NativeType = VkPhysicalDeviceMaintenance3Properties; @@ -56630,28 +53442,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceMaintenance3Properties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMaintenance3Properties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceMaintenance3Properties &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMaintenance3Properties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxPerSetDescriptors, maxMemoryAllocationSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMaintenance3Properties const & ) const = default; #else bool operator==( PhysicalDeviceMaintenance3Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors ) && - ( maxMemoryAllocationSize == rhs.maxMemoryAllocationSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMaintenance3Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -56677,26 +53501,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties const & - physicalDeviceMaintenance3Properties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMaintenance3Properties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMaintenance3Properties.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMaintenance3Properties.maxPerSetDescriptors ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceMaintenance3Properties.maxMemoryAllocationSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceMaintenance4FeaturesKHR { using NativeType = VkPhysicalDeviceMaintenance4FeaturesKHR; @@ -56745,27 +53549,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceMaintenance4FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMaintenance4FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceMaintenance4FeaturesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMaintenance4FeaturesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maintenance4 ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMaintenance4FeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceMaintenance4FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance4 == rhs.maintenance4 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMaintenance4FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -56789,24 +53603,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceMaintenance4FeaturesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4FeaturesKHR const & - physicalDeviceMaintenance4FeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMaintenance4FeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMaintenance4FeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMaintenance4FeaturesKHR.maintenance4 ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceMaintenance4PropertiesKHR { using NativeType = VkPhysicalDeviceMaintenance4PropertiesKHR; @@ -56839,27 +53635,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceMaintenance4PropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMaintenance4PropertiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceMaintenance4PropertiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMaintenance4PropertiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxBufferSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMaintenance4PropertiesKHR const & ) const = default; #else bool operator==( PhysicalDeviceMaintenance4PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxBufferSize == rhs.maxBufferSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMaintenance4PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -56884,25 +53690,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceMaintenance4PropertiesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4PropertiesKHR const & - physicalDeviceMaintenance4PropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMaintenance4PropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMaintenance4PropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceMaintenance4PropertiesKHR.maxBufferSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceMemoryBudgetPropertiesEXT { using NativeType = VkPhysicalDeviceMemoryBudgetPropertiesEXT; @@ -56938,28 +53725,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceMemoryBudgetPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMemoryBudgetPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceMemoryBudgetPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMemoryBudgetPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, heapBudget, heapUsage ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMemoryBudgetPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( heapBudget == rhs.heapBudget ) && - ( heapUsage == rhs.heapUsage ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -56985,33 +53784,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceMemoryBudgetPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT const & - physicalDeviceMemoryBudgetPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMemoryBudgetPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMemoryBudgetPropertiesEXT.pNext ); - for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) - { - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceMemoryBudgetPropertiesEXT.heapBudget[i] ); - } - for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) - { - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceMemoryBudgetPropertiesEXT.heapUsage[i] ); - } - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceMemoryPriorityFeaturesEXT { using NativeType = VkPhysicalDeviceMemoryPriorityFeaturesEXT; @@ -57060,27 +53832,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceMemoryPriorityFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMemoryPriorityFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceMemoryPriorityFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMemoryPriorityFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryPriority ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMemoryPriorityFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryPriority == rhs.memoryPriority ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -57105,25 +53887,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceMemoryPriorityFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT const & - physicalDeviceMemoryPriorityFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMemoryPriorityFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMemoryPriorityFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMemoryPriorityFeaturesEXT.memoryPriority ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceMemoryProperties { using NativeType = VkPhysicalDeviceMemoryProperties; @@ -57157,28 +53920,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceMemoryProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMemoryProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceMemoryProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMemoryProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( memoryTypeCount, memoryTypes, memoryHeapCount, memoryHeaps ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMemoryProperties const & ) const = default; #else bool operator==( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( memoryTypeCount == rhs.memoryTypeCount ) && ( memoryTypes == rhs.memoryTypes ) && - ( memoryHeapCount == rhs.memoryHeapCount ) && ( memoryHeaps == rhs.memoryHeaps ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -57197,31 +53972,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "PhysicalDeviceMemoryProperties is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties const & physicalDeviceMemoryProperties ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMemoryProperties.memoryTypeCount ); - for ( size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i ) - { - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryType, seed, physicalDeviceMemoryProperties.memoryTypes[i] ); - } - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMemoryProperties.memoryHeapCount ); - for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) - { - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::MemoryHeap, seed, physicalDeviceMemoryProperties.memoryHeaps[i] ); - } - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceMemoryProperties2 { using NativeType = VkPhysicalDeviceMemoryProperties2; @@ -57252,27 +54002,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceMemoryProperties2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMemoryProperties2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceMemoryProperties2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMemoryProperties2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMemoryProperties2 const & ) const = default; #else bool operator==( PhysicalDeviceMemoryProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryProperties == rhs.memoryProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMemoryProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -57297,26 +54059,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 const & physicalDeviceMemoryProperties2 ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMemoryProperties2.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMemoryProperties2.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties, seed, physicalDeviceMemoryProperties2.memoryProperties ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceMeshShaderFeaturesNV { using NativeType = VkPhysicalDeviceMeshShaderFeaturesNV; @@ -57373,28 +54115,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceMeshShaderFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMeshShaderFeaturesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceMeshShaderFeaturesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMeshShaderFeaturesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, taskShader, meshShader ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMeshShaderFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( taskShader == rhs.taskShader ) && - ( meshShader == rhs.meshShader ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -57419,25 +54173,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceMeshShaderFeaturesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV const & - physicalDeviceMeshShaderFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMeshShaderFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMeshShaderFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMeshShaderFeaturesNV.taskShader ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMeshShaderFeaturesNV.meshShader ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceMeshShaderPropertiesNV { using NativeType = VkPhysicalDeviceMeshShaderPropertiesNV; @@ -57494,40 +54229,65 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceMeshShaderPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMeshShaderPropertiesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceMeshShaderPropertiesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMeshShaderPropertiesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxDrawMeshTasksCount, + maxTaskWorkGroupInvocations, + maxTaskWorkGroupSize, + maxTaskTotalMemorySize, + maxTaskOutputCount, + maxMeshWorkGroupInvocations, + maxMeshWorkGroupSize, + maxMeshTotalMemorySize, + maxMeshOutputVertices, + maxMeshOutputPrimitives, + maxMeshMultiviewViewCount, + meshOutputPerVertexGranularity, + meshOutputPerPrimitiveGranularity ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMeshShaderPropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxDrawMeshTasksCount == rhs.maxDrawMeshTasksCount ) && - ( maxTaskWorkGroupInvocations == rhs.maxTaskWorkGroupInvocations ) && - ( maxTaskWorkGroupSize == rhs.maxTaskWorkGroupSize ) && - ( maxTaskTotalMemorySize == rhs.maxTaskTotalMemorySize ) && - ( maxTaskOutputCount == rhs.maxTaskOutputCount ) && - ( maxMeshWorkGroupInvocations == rhs.maxMeshWorkGroupInvocations ) && - ( maxMeshWorkGroupSize == rhs.maxMeshWorkGroupSize ) && - ( maxMeshTotalMemorySize == rhs.maxMeshTotalMemorySize ) && - ( maxMeshOutputVertices == rhs.maxMeshOutputVertices ) && - ( maxMeshOutputPrimitives == rhs.maxMeshOutputPrimitives ) && - ( maxMeshMultiviewViewCount == rhs.maxMeshMultiviewViewCount ) && - ( meshOutputPerVertexGranularity == rhs.meshOutputPerVertexGranularity ) && - ( meshOutputPerPrimitiveGranularity == rhs.meshOutputPerPrimitiveGranularity ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -57563,42 +54323,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceMeshShaderPropertiesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV const & - physicalDeviceMeshShaderPropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMeshShaderPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMeshShaderPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxDrawMeshTasksCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupInvocations ); - for ( size_t i = 0; i < 3; ++i ) - { - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupSize[i] ); - } - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxTaskTotalMemorySize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxTaskOutputCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupInvocations ); - for ( size_t i = 0; i < 3; ++i ) - { - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupSize[i] ); - } - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshTotalMemorySize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputVertices ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputPrimitives ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.maxMeshMultiviewViewCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerVertexGranularity ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerPrimitiveGranularity ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceMultiDrawFeaturesEXT { using NativeType = VkPhysicalDeviceMultiDrawFeaturesEXT; @@ -57646,27 +54370,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceMultiDrawFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMultiDrawFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceMultiDrawFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMultiDrawFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, multiDraw ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMultiDrawFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiDraw == rhs.multiDraw ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -57690,24 +54424,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceMultiDrawFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT const & - physicalDeviceMultiDrawFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiDrawFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiDrawFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMultiDrawFeaturesEXT.multiDraw ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceMultiDrawPropertiesEXT { using NativeType = VkPhysicalDeviceMultiDrawPropertiesEXT; @@ -57739,27 +54455,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceMultiDrawPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMultiDrawPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceMultiDrawPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMultiDrawPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxMultiDrawCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMultiDrawPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxMultiDrawCount == rhs.maxMultiDrawCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -57783,24 +54509,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceMultiDrawPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT const & - physicalDeviceMultiDrawPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiDrawPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiDrawPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMultiDrawPropertiesEXT.maxMultiDrawCount ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceMultiviewFeatures { using NativeType = VkPhysicalDeviceMultiviewFeatures; @@ -57864,29 +54572,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceMultiviewFeatures const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMultiviewFeatures const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceMultiviewFeatures &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMultiviewFeatures &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, multiview, multiviewGeometryShader, multiviewTessellationShader ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMultiviewFeatures const & ) const = default; #else bool operator==( PhysicalDeviceMultiviewFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiview == rhs.multiview ) && - ( multiviewGeometryShader == rhs.multiviewGeometryShader ) && - ( multiviewTessellationShader == rhs.multiviewTessellationShader ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMultiviewFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -57913,29 +54633,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures const & physicalDeviceMultiviewFeatures ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiviewFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiviewFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMultiviewFeatures.multiview ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMultiviewFeatures.multiviewGeometryShader ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMultiviewFeatures.multiviewTessellationShader ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { using NativeType = VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; @@ -57971,28 +54668,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, perViewPositionAllComponents ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & ) const = default; #else bool operator==( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( perViewPositionAllComponents == rhs.perViewPositionAllComponents ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -58018,27 +54724,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & - physicalDeviceMultiviewPerViewAttributesPropertiesNVX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceMultiviewPerViewAttributesPropertiesNVX.perViewPositionAllComponents ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceMultiviewProperties { using NativeType = VkPhysicalDeviceMultiviewProperties; @@ -58072,29 +54757,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceMultiviewProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMultiviewProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceMultiviewProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMultiviewProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxMultiviewViewCount, maxMultiviewInstanceIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMultiviewProperties const & ) const = default; #else bool operator==( PhysicalDeviceMultiviewProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxMultiviewViewCount == rhs.maxMultiviewViewCount ) && - ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMultiviewProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -58120,25 +54813,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties const & - physicalDeviceMultiviewProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMultiviewProperties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMultiviewProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMultiviewProperties.maxMultiviewViewCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceMultiviewProperties.maxMultiviewInstanceIndex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE { using NativeType = VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE; @@ -58189,27 +54863,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, mutableDescriptorType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & ) const = default; #else bool operator==( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mutableDescriptorType == rhs.mutableDescriptorType ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -58234,26 +54918,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceMutableDescriptorTypeFeaturesVALVE; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & - physicalDeviceMutableDescriptorTypeFeaturesVALVE ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceMutableDescriptorTypeFeaturesVALVE.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceMutableDescriptorTypeFeaturesVALVE.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceMutableDescriptorTypeFeaturesVALVE.mutableDescriptorType ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDevicePCIBusInfoPropertiesEXT { using NativeType = VkPhysicalDevicePCIBusInfoPropertiesEXT; @@ -58292,28 +54956,42 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDevicePCIBusInfoPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePCIBusInfoPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDevicePCIBusInfoPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePCIBusInfoPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pciDomain, pciBus, pciDevice, pciFunction ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePCIBusInfoPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pciDomain == rhs.pciDomain ) && - ( pciBus == rhs.pciBus ) && ( pciDevice == rhs.pciDevice ) && ( pciFunction == rhs.pciFunction ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -58340,27 +55018,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDevicePCIBusInfoPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT const & - physicalDevicePCIBusInfoPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePCIBusInfoPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePCIBusInfoPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePCIBusInfoPropertiesEXT.pciDomain ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePCIBusInfoPropertiesEXT.pciBus ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePCIBusInfoPropertiesEXT.pciDevice ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePCIBusInfoPropertiesEXT.pciFunction ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { using NativeType = VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; @@ -58412,28 +55069,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pageableDeviceLocalMemory ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( pageableDeviceLocalMemory == rhs.pageableDeviceLocalMemory ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -58458,27 +55124,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & - physicalDevicePageableDeviceLocalMemoryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pageableDeviceLocalMemory ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDevicePerformanceQueryFeaturesKHR { using NativeType = VkPhysicalDevicePerformanceQueryFeaturesKHR; @@ -58537,29 +55182,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDevicePerformanceQueryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePerformanceQueryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDevicePerformanceQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePerformanceQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, performanceCounterQueryPools, performanceCounterMultipleQueryPools ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePerformanceQueryFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( performanceCounterQueryPools == rhs.performanceCounterQueryPools ) && - ( performanceCounterMultipleQueryPools == rhs.performanceCounterMultipleQueryPools ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -58585,29 +55241,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDevicePerformanceQueryFeaturesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR const & - physicalDevicePerformanceQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePerformanceQueryFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePerformanceQueryFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterQueryPools ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDevicePerformanceQueryFeaturesKHR.performanceCounterMultipleQueryPools ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDevicePerformanceQueryPropertiesKHR { using NativeType = VkPhysicalDevicePerformanceQueryPropertiesKHR; @@ -58642,28 +55275,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDevicePerformanceQueryPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePerformanceQueryPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDevicePerformanceQueryPropertiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePerformanceQueryPropertiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, allowCommandBufferQueryCopies ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePerformanceQueryPropertiesKHR const & ) const = default; #else bool operator==( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( allowCommandBufferQueryCopies == rhs.allowCommandBufferQueryCopies ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -58688,26 +55330,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDevicePerformanceQueryPropertiesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR const & - physicalDevicePerformanceQueryPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePerformanceQueryPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePerformanceQueryPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePerformanceQueryPropertiesKHR.allowCommandBufferQueryCopies ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDevicePipelineCreationCacheControlFeaturesEXT { using NativeType = VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT; @@ -58759,28 +55381,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineCreationCacheControl ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( pipelineCreationCacheControl == rhs.pipelineCreationCacheControl ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -58806,27 +55437,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDevicePipelineCreationCacheControlFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & - physicalDevicePipelineCreationCacheControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePipelineCreationCacheControlFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePipelineCreationCacheControlFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDevicePipelineCreationCacheControlFeaturesEXT.pipelineCreationCacheControl ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { using NativeType = VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR; @@ -58878,28 +55488,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineExecutableInfo ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( pipelineExecutableInfo == rhs.pipelineExecutableInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -58925,27 +55544,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & - physicalDevicePipelineExecutablePropertiesFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDevicePipelineExecutablePropertiesFeaturesKHR.pipelineExecutableInfo ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDevicePointClippingProperties { using NativeType = VkPhysicalDevicePointClippingProperties; @@ -58980,27 +55578,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDevicePointClippingProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePointClippingProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDevicePointClippingProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePointClippingProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pointClippingBehavior ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePointClippingProperties const & ) const = default; #else bool operator==( PhysicalDevicePointClippingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pointClippingBehavior == rhs.pointClippingBehavior ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePointClippingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -59026,25 +55636,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties const & - physicalDevicePointClippingProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePointClippingProperties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePointClippingProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PointClippingBehavior, seed, physicalDevicePointClippingProperties.pointClippingBehavior ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_ENABLE_BETA_EXTENSIONS ) struct PhysicalDevicePortabilitySubsetFeaturesKHR { @@ -59221,39 +55812,69 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDevicePortabilitySubsetFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePortabilitySubsetFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDevicePortabilitySubsetFeaturesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePortabilitySubsetFeaturesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + constantAlphaColorBlendFactors, + events, + imageViewFormatReinterpretation, + imageViewFormatSwizzle, + imageView2DOn3DImage, + multisampleArrayImage, + mutableComparisonSamplers, + pointPolygons, + samplerMipLodBias, + separateStencilMaskRef, + shaderSampleRateInterpolationFunctions, + tessellationIsolines, + tessellationPointMode, + triangleFans, + vertexAttributeAccessBeyondStride ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePortabilitySubsetFeaturesKHR const & ) const = default; # else bool operator==( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( constantAlphaColorBlendFactors == rhs.constantAlphaColorBlendFactors ) && ( events == rhs.events ) && - ( imageViewFormatReinterpretation == rhs.imageViewFormatReinterpretation ) && - ( imageViewFormatSwizzle == rhs.imageViewFormatSwizzle ) && - ( imageView2DOn3DImage == rhs.imageView2DOn3DImage ) && - ( multisampleArrayImage == rhs.multisampleArrayImage ) && - ( mutableComparisonSamplers == rhs.mutableComparisonSamplers ) && ( pointPolygons == rhs.pointPolygons ) && - ( samplerMipLodBias == rhs.samplerMipLodBias ) && - ( separateStencilMaskRef == rhs.separateStencilMaskRef ) && - ( shaderSampleRateInterpolationFunctions == rhs.shaderSampleRateInterpolationFunctions ) && - ( tessellationIsolines == rhs.tessellationIsolines ) && - ( tessellationPointMode == rhs.tessellationPointMode ) && ( triangleFans == rhs.triangleFans ) && - ( vertexAttributeAccessBeyondStride == rhs.vertexAttributeAccessBeyondStride ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -59291,56 +55912,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = PhysicalDevicePortabilitySubsetFeaturesKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR const & - physicalDevicePortabilitySubsetFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePortabilitySubsetFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePortabilitySubsetFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.constantAlphaColorBlendFactors ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.events ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatReinterpretation ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatSwizzle ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.imageView2DOn3DImage ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.multisampleArrayImage ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.mutableComparisonSamplers ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.pointPolygons ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.samplerMipLodBias ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.separateStencilMaskRef ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDevicePortabilitySubsetFeaturesKHR.shaderSampleRateInterpolationFunctions ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationIsolines ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationPointMode ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePortabilitySubsetFeaturesKHR.triangleFans ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDevicePortabilitySubsetFeaturesKHR.vertexAttributeAccessBeyondStride ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -59393,28 +55964,37 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDevicePortabilitySubsetPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePortabilitySubsetPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDevicePortabilitySubsetPropertiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePortabilitySubsetPropertiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minVertexInputBindingStrideAlignment ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePortabilitySubsetPropertiesKHR const & ) const = default; # else bool operator==( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( minVertexInputBindingStrideAlignment == rhs.minVertexInputBindingStrideAlignment ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -59438,27 +56018,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = PhysicalDevicePortabilitySubsetPropertiesKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR const & - physicalDevicePortabilitySubsetPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePortabilitySubsetPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePortabilitySubsetPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDevicePortabilitySubsetPropertiesKHR.minVertexInputBindingStrideAlignment ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct PhysicalDevicePresentIdFeaturesKHR @@ -59508,27 +56067,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDevicePresentIdFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePresentIdFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDevicePresentIdFeaturesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePresentIdFeaturesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentId ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePresentIdFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDevicePresentIdFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentId == rhs.presentId ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePresentIdFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -59552,24 +56121,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDevicePresentIdFeaturesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR const & - physicalDevicePresentIdFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePresentIdFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePresentIdFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePresentIdFeaturesKHR.presentId ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDevicePresentWaitFeaturesKHR { using NativeType = VkPhysicalDevicePresentWaitFeaturesKHR; @@ -59617,27 +56168,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDevicePresentWaitFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePresentWaitFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDevicePresentWaitFeaturesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePresentWaitFeaturesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentWait ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePresentWaitFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentWait == rhs.presentWait ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -59661,24 +56222,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDevicePresentWaitFeaturesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR const & - physicalDevicePresentWaitFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePresentWaitFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePresentWaitFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePresentWaitFeaturesKHR.presentWait ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { using NativeType = VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; @@ -59740,29 +56283,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, primitiveTopologyListRestart, primitiveTopologyPatchListRestart ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( primitiveTopologyListRestart == rhs.primitiveTopologyListRestart ) && - ( primitiveTopologyPatchListRestart == rhs.primitiveTopologyPatchListRestart ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -59789,30 +56343,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & - physicalDevicePrimitiveTopologyListRestartFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyListRestart ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyPatchListRestart ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDevicePrivateDataFeaturesEXT { using NativeType = VkPhysicalDevicePrivateDataFeaturesEXT; @@ -59860,27 +56390,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDevicePrivateDataFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePrivateDataFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDevicePrivateDataFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePrivateDataFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, privateData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePrivateDataFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDevicePrivateDataFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( privateData == rhs.privateData ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePrivateDataFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -59904,24 +56444,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDevicePrivateDataFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeaturesEXT const & - physicalDevicePrivateDataFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePrivateDataFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePrivateDataFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDevicePrivateDataFeaturesEXT.privateData ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceSparseProperties { using NativeType = VkPhysicalDeviceSparseProperties; @@ -59957,31 +56479,45 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceSparseProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSparseProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceSparseProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSparseProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( residencyStandard2DBlockShape, + residencyStandard2DMultisampleBlockShape, + residencyStandard3DBlockShape, + residencyAlignedMipSize, + residencyNonResidentStrict ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSparseProperties const & ) const = default; #else bool operator==( PhysicalDeviceSparseProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape ) && - ( residencyStandard2DMultisampleBlockShape == rhs.residencyStandard2DMultisampleBlockShape ) && - ( residencyStandard3DBlockShape == rhs.residencyStandard3DBlockShape ) && - ( residencyAlignedMipSize == rhs.residencyAlignedMipSize ) && - ( residencyNonResidentStrict == rhs.residencyNonResidentStrict ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSparseProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -60001,31 +56537,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "PhysicalDeviceSparseProperties is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const & physicalDeviceSparseProperties ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyStandard2DBlockShape ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyStandard2DMultisampleBlockShape ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyStandard3DBlockShape ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyAlignedMipSize ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSparseProperties.residencyNonResidentStrict ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceProperties { using NativeType = VkPhysicalDeviceProperties; @@ -60068,30 +56579,53 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const &, + VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( apiVersion, + driverVersion, + vendorID, + deviceID, + deviceType, + deviceName, + pipelineCacheUUID, + limits, + sparseProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceProperties const & ) const = default; #else bool operator==( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( apiVersion == rhs.apiVersion ) && ( driverVersion == rhs.driverVersion ) && - ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) && ( deviceType == rhs.deviceType ) && - ( deviceName == rhs.deviceName ) && ( pipelineCacheUUID == rhs.pipelineCacheUUID ) && - ( limits == rhs.limits ) && ( sparseProperties == rhs.sparseProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -60114,37 +56648,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "PhysicalDeviceProperties is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const & physicalDeviceProperties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceProperties.apiVersion ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceProperties.driverVersion ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceProperties.vendorID ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceProperties.deviceID ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PhysicalDeviceType, seed, physicalDeviceProperties.deviceType ); - for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceProperties.deviceName[i] ); - } - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceProperties.pipelineCacheUUID[i] ); - } - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits, seed, physicalDeviceProperties.limits ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties, seed, physicalDeviceProperties.sparseProperties ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceProperties2 { using NativeType = VkPhysicalDeviceProperties2; @@ -60174,27 +56677,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceProperties2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceProperties2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceProperties2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceProperties2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, properties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceProperties2 const & ) const = default; #else bool operator==( PhysicalDeviceProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -60218,25 +56733,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 const & physicalDeviceProperties2 ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProperties2.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProperties2.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties, seed, physicalDeviceProperties2.properties ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceProtectedMemoryFeatures { using NativeType = VkPhysicalDeviceProtectedMemoryFeatures; @@ -60285,27 +56781,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceProtectedMemoryFeatures const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceProtectedMemoryFeatures const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceProtectedMemoryFeatures &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceProtectedMemoryFeatures &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, protectedMemory ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceProtectedMemoryFeatures const & ) const = default; #else bool operator==( PhysicalDeviceProtectedMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedMemory == rhs.protectedMemory ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceProtectedMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -60329,25 +56835,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceProtectedMemoryFeatures; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures const & - physicalDeviceProtectedMemoryFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProtectedMemoryFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProtectedMemoryFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceProtectedMemoryFeatures.protectedMemory ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceProtectedMemoryProperties { using NativeType = VkPhysicalDeviceProtectedMemoryProperties; @@ -60381,27 +56868,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceProtectedMemoryProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceProtectedMemoryProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceProtectedMemoryProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceProtectedMemoryProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, protectedNoFault ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceProtectedMemoryProperties const & ) const = default; #else bool operator==( PhysicalDeviceProtectedMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedNoFault == rhs.protectedNoFault ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceProtectedMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -60426,25 +56923,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceProtectedMemoryProperties; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties const & - physicalDeviceProtectedMemoryProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProtectedMemoryProperties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProtectedMemoryProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceProtectedMemoryProperties.protectedNoFault ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceProvokingVertexFeaturesEXT { using NativeType = VkPhysicalDeviceProvokingVertexFeaturesEXT; @@ -60503,28 +56981,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceProvokingVertexFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceProvokingVertexFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceProvokingVertexFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceProvokingVertexFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, provokingVertexLast, transformFeedbackPreservesProvokingVertex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceProvokingVertexFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexLast == rhs.provokingVertexLast ) && - ( transformFeedbackPreservesProvokingVertex == rhs.transformFeedbackPreservesProvokingVertex ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -60550,29 +57040,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceProvokingVertexFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT const & - physicalDeviceProvokingVertexFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProvokingVertexFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProvokingVertexFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceProvokingVertexFeaturesEXT.provokingVertexLast ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceProvokingVertexFeaturesEXT.transformFeedbackPreservesProvokingVertex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceProvokingVertexPropertiesEXT { using NativeType = VkPhysicalDeviceProvokingVertexPropertiesEXT; @@ -60609,30 +57076,41 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceProvokingVertexPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceProvokingVertexPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceProvokingVertexPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceProvokingVertexPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, provokingVertexModePerPipeline, transformFeedbackPreservesTriangleFanProvokingVertex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceProvokingVertexPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( provokingVertexModePerPipeline == rhs.provokingVertexModePerPipeline ) && - ( transformFeedbackPreservesTriangleFanProvokingVertex == - rhs.transformFeedbackPreservesTriangleFanProvokingVertex ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -60658,30 +57136,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceProvokingVertexPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT const & - physicalDeviceProvokingVertexPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceProvokingVertexPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceProvokingVertexPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceProvokingVertexPropertiesEXT.provokingVertexModePerPipeline ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceProvokingVertexPropertiesEXT.transformFeedbackPreservesTriangleFanProvokingVertex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDevicePushDescriptorPropertiesKHR { using NativeType = VkPhysicalDevicePushDescriptorPropertiesKHR; @@ -60716,27 +57170,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDevicePushDescriptorPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePushDescriptorPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDevicePushDescriptorPropertiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDevicePushDescriptorPropertiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxPushDescriptors ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePushDescriptorPropertiesKHR const & ) const = default; #else bool operator==( PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPushDescriptors == rhs.maxPushDescriptors ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -60761,25 +57225,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDevicePushDescriptorPropertiesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR const & - physicalDevicePushDescriptorPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDevicePushDescriptorPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDevicePushDescriptorPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDevicePushDescriptorPropertiesKHR.maxPushDescriptors ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT { using NativeType = VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT; @@ -60829,28 +57274,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, formatRgba10x6WithoutYCbCrSampler ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( formatRgba10x6WithoutYCbCrSampler == rhs.formatRgba10x6WithoutYCbCrSampler ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -60875,26 +57329,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceRGBA10X6FormatsFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & - physicalDeviceRGBA10X6FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.formatRgba10x6WithoutYCbCrSampler ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM { using NativeType = VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM; @@ -60968,30 +57402,45 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + rasterizationOrderColorAttachmentAccess, + rasterizationOrderDepthAttachmentAccess, + rasterizationOrderStencilAttachmentAccess ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & ) const = default; #else bool operator==( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( rasterizationOrderColorAttachmentAccess == rhs.rasterizationOrderColorAttachmentAccess ) && - ( rasterizationOrderDepthAttachmentAccess == rhs.rasterizationOrderDepthAttachmentAccess ) && - ( rasterizationOrderStencilAttachmentAccess == rhs.rasterizationOrderStencilAttachmentAccess ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -61021,36 +57470,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & - physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.rasterizationOrderColorAttachmentAccess ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.rasterizationOrderDepthAttachmentAccess ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.rasterizationOrderStencilAttachmentAccess ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceRayQueryFeaturesKHR { using NativeType = VkPhysicalDeviceRayQueryFeaturesKHR; @@ -61097,27 +57516,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceRayQueryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRayQueryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceRayQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRayQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rayQuery ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRayQueryFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayQuery == rhs.rayQuery ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -61141,24 +57570,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceRayQueryFeaturesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR const & - physicalDeviceRayQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayQueryFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayQueryFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRayQueryFeaturesKHR.rayQuery ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceRayTracingMotionBlurFeaturesNV { using NativeType = VkPhysicalDeviceRayTracingMotionBlurFeaturesNV; @@ -61218,28 +57629,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rayTracingMotionBlur, rayTracingMotionBlurPipelineTraceRaysIndirect ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingMotionBlur == rhs.rayTracingMotionBlur ) && - ( rayTracingMotionBlurPipelineTraceRaysIndirect == rhs.rayTracingMotionBlurPipelineTraceRaysIndirect ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -61265,30 +57688,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceRayTracingMotionBlurFeaturesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV const & - physicalDeviceRayTracingMotionBlurFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayTracingMotionBlurFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayTracingMotionBlurFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlur ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlurPipelineTraceRaysIndirect ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceRayTracingPipelineFeaturesKHR { using NativeType = VkPhysicalDeviceRayTracingPipelineFeaturesKHR; @@ -61376,33 +57775,49 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + rayTracingPipeline, + rayTracingPipelineShaderGroupHandleCaptureReplay, + rayTracingPipelineShaderGroupHandleCaptureReplayMixed, + rayTracingPipelineTraceRaysIndirect, + rayTraversalPrimitiveCulling ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRayTracingPipelineFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingPipeline == rhs.rayTracingPipeline ) && - ( rayTracingPipelineShaderGroupHandleCaptureReplay == - rhs.rayTracingPipelineShaderGroupHandleCaptureReplay ) && - ( rayTracingPipelineShaderGroupHandleCaptureReplayMixed == - rhs.rayTracingPipelineShaderGroupHandleCaptureReplayMixed ) && - ( rayTracingPipelineTraceRaysIndirect == rhs.rayTracingPipelineTraceRaysIndirect ) && - ( rayTraversalPrimitiveCulling == rhs.rayTraversalPrimitiveCulling ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -61431,39 +57846,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceRayTracingPipelineFeaturesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR const & - physicalDeviceRayTracingPipelineFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayTracingPipelineFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayTracingPipelineFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplay ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplayMixed ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineTraceRaysIndirect ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTraversalPrimitiveCulling ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceRayTracingPipelinePropertiesKHR { using NativeType = VkPhysicalDeviceRayTracingPipelinePropertiesKHR; @@ -61512,35 +57894,55 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderGroupHandleSize, + maxRayRecursionDepth, + maxShaderGroupStride, + shaderGroupBaseAlignment, + shaderGroupHandleCaptureReplaySize, + maxRayDispatchInvocationCount, + shaderGroupHandleAlignment, + maxRayHitAttributeSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRayTracingPipelinePropertiesKHR const & ) const = default; #else bool operator==( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderGroupHandleSize == rhs.shaderGroupHandleSize ) && - ( maxRayRecursionDepth == rhs.maxRayRecursionDepth ) && - ( maxShaderGroupStride == rhs.maxShaderGroupStride ) && - ( shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment ) && - ( shaderGroupHandleCaptureReplaySize == rhs.shaderGroupHandleCaptureReplaySize ) && - ( maxRayDispatchInvocationCount == rhs.maxRayDispatchInvocationCount ) && - ( shaderGroupHandleAlignment == rhs.shaderGroupHandleAlignment ) && - ( maxRayHitAttributeSize == rhs.maxRayHitAttributeSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -61572,34 +57974,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceRayTracingPipelinePropertiesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR const & - physicalDeviceRayTracingPipelinePropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayTracingPipelinePropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayTracingPipelinePropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleSize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayRecursionDepth ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxShaderGroupStride ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupBaseAlignment ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleCaptureReplaySize ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayDispatchInvocationCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleAlignment ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayHitAttributeSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceRayTracingPropertiesNV { using NativeType = VkPhysicalDeviceRayTracingPropertiesNV; @@ -61646,33 +58020,55 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceRayTracingPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRayTracingPropertiesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceRayTracingPropertiesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRayTracingPropertiesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderGroupHandleSize, + maxRecursionDepth, + maxShaderGroupStride, + shaderGroupBaseAlignment, + maxGeometryCount, + maxInstanceCount, + maxTriangleCount, + maxDescriptorSetAccelerationStructures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRayTracingPropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceRayTracingPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderGroupHandleSize == rhs.shaderGroupHandleSize ) && ( maxRecursionDepth == rhs.maxRecursionDepth ) && - ( maxShaderGroupStride == rhs.maxShaderGroupStride ) && - ( shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment ) && - ( maxGeometryCount == rhs.maxGeometryCount ) && ( maxInstanceCount == rhs.maxInstanceCount ) && - ( maxTriangleCount == rhs.maxTriangleCount ) && - ( maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRayTracingPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -61703,32 +58099,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceRayTracingPropertiesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV const & - physicalDeviceRayTracingPropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRayTracingPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRayTracingPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPropertiesNV.shaderGroupHandleSize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPropertiesNV.maxRecursionDepth ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPropertiesNV.maxShaderGroupStride ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceRayTracingPropertiesNV.shaderGroupBaseAlignment ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceRayTracingPropertiesNV.maxGeometryCount ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceRayTracingPropertiesNV.maxInstanceCount ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceRayTracingPropertiesNV.maxTriangleCount ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceRayTracingPropertiesNV.maxDescriptorSetAccelerationStructures ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV { using NativeType = VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV; @@ -61780,28 +58150,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, representativeFragmentTest ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( representativeFragmentTest == rhs.representativeFragmentTest ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -61826,27 +58205,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceRepresentativeFragmentTestFeaturesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & - physicalDeviceRepresentativeFragmentTestFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceRepresentativeFragmentTestFeaturesNV.representativeFragmentTest ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceRobustness2FeaturesEXT { using NativeType = VkPhysicalDeviceRobustness2FeaturesEXT; @@ -61912,28 +58270,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceRobustness2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRobustness2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceRobustness2FeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRobustness2FeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, robustBufferAccess2, robustImageAccess2, nullDescriptor ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRobustness2FeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustBufferAccess2 == rhs.robustBufferAccess2 ) && - ( robustImageAccess2 == rhs.robustImageAccess2 ) && ( nullDescriptor == rhs.nullDescriptor ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -61959,28 +58330,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceRobustness2FeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT const & - physicalDeviceRobustness2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRobustness2FeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRobustness2FeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRobustness2FeaturesEXT.robustBufferAccess2 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRobustness2FeaturesEXT.robustImageAccess2 ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceRobustness2FeaturesEXT.nullDescriptor ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceRobustness2PropertiesEXT { using NativeType = VkPhysicalDeviceRobustness2PropertiesEXT; @@ -62016,29 +58365,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceRobustness2PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRobustness2PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceRobustness2PropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceRobustness2PropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, robustStorageBufferAccessSizeAlignment, robustUniformBufferAccessSizeAlignment ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRobustness2PropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( robustStorageBufferAccessSizeAlignment == rhs.robustStorageBufferAccessSizeAlignment ) && - ( robustUniformBufferAccessSizeAlignment == rhs.robustUniformBufferAccessSizeAlignment ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -62064,29 +58424,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceRobustness2PropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT const & - physicalDeviceRobustness2PropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceRobustness2PropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceRobustness2PropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, - seed, - physicalDeviceRobustness2PropertiesEXT.robustStorageBufferAccessSizeAlignment ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, - seed, - physicalDeviceRobustness2PropertiesEXT.robustUniformBufferAccessSizeAlignment ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceSampleLocationsPropertiesEXT { using NativeType = VkPhysicalDeviceSampleLocationsPropertiesEXT; @@ -62129,32 +58466,49 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceSampleLocationsPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSampleLocationsPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceSampleLocationsPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSampleLocationsPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::Bool32 const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + sampleLocationSampleCounts, + maxSampleLocationGridSize, + sampleLocationCoordinateRange, + sampleLocationSubPixelBits, + variableSampleLocations ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSampleLocationsPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( sampleLocationSampleCounts == rhs.sampleLocationSampleCounts ) && - ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ) && - ( sampleLocationCoordinateRange == rhs.sampleLocationCoordinateRange ) && - ( sampleLocationSubPixelBits == rhs.sampleLocationSubPixelBits ) && - ( variableSampleLocations == rhs.variableSampleLocations ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -62183,37 +58537,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceSampleLocationsPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT const & - physicalDeviceSampleLocationsPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSampleLocationsPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSampleLocationsPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlags, - seed, - physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSampleCounts ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceSampleLocationsPropertiesEXT.maxSampleLocationGridSize ); - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( - float, seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationCoordinateRange[i] ); - } - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSubPixelBits ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSampleLocationsPropertiesEXT.variableSampleLocations ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceSamplerFilterMinmaxProperties { using NativeType = VkPhysicalDeviceSamplerFilterMinmaxProperties; @@ -62250,29 +58573,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceSamplerFilterMinmaxProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSamplerFilterMinmaxProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceSamplerFilterMinmaxProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSamplerFilterMinmaxProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, filterMinmaxSingleComponentFormats, filterMinmaxImageComponentMapping ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSamplerFilterMinmaxProperties const & ) const = default; #else bool operator==( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) && - ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -62299,30 +58633,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties const & - physicalDeviceSamplerFilterMinmaxProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSamplerFilterMinmaxProperties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSamplerFilterMinmaxProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxSingleComponentFormats ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxImageComponentMapping ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceSamplerYcbcrConversionFeatures { using NativeType = VkPhysicalDeviceSamplerYcbcrConversionFeatures; @@ -62372,28 +58682,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceSamplerYcbcrConversionFeatures const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSamplerYcbcrConversionFeatures const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceSamplerYcbcrConversionFeatures &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSamplerYcbcrConversionFeatures &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, samplerYcbcrConversion ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSamplerYcbcrConversionFeatures const & ) const = default; #else bool operator==( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( samplerYcbcrConversion == rhs.samplerYcbcrConversion ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -62419,26 +58738,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures const & - physicalDeviceSamplerYcbcrConversionFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSamplerYcbcrConversionFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSamplerYcbcrConversionFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSamplerYcbcrConversionFeatures.samplerYcbcrConversion ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceScalarBlockLayoutFeatures { using NativeType = VkPhysicalDeviceScalarBlockLayoutFeatures; @@ -62486,27 +58785,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceScalarBlockLayoutFeatures const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceScalarBlockLayoutFeatures const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceScalarBlockLayoutFeatures &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceScalarBlockLayoutFeatures &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, scalarBlockLayout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceScalarBlockLayoutFeatures const & ) const = default; #else bool operator==( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( scalarBlockLayout == rhs.scalarBlockLayout ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -62532,25 +58841,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures const & - physicalDeviceScalarBlockLayoutFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceScalarBlockLayoutFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceScalarBlockLayoutFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceScalarBlockLayoutFeatures.scalarBlockLayout ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures { using NativeType = VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures; @@ -62602,28 +58892,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, separateDepthStencilLayouts ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & ) const = default; #else bool operator==( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( separateDepthStencilLayouts == rhs.separateDepthStencilLayouts ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -62649,27 +58948,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & - physicalDeviceSeparateDepthStencilLayoutsFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceSeparateDepthStencilLayoutsFeatures.separateDepthStencilLayouts ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT { using NativeType = VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT; @@ -62818,39 +59096,63 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderBufferFloat16Atomics, + shaderBufferFloat16AtomicAdd, + shaderBufferFloat16AtomicMinMax, + shaderBufferFloat32AtomicMinMax, + shaderBufferFloat64AtomicMinMax, + shaderSharedFloat16Atomics, + shaderSharedFloat16AtomicAdd, + shaderSharedFloat16AtomicMinMax, + shaderSharedFloat32AtomicMinMax, + shaderSharedFloat64AtomicMinMax, + shaderImageFloat32AtomicMinMax, + sparseImageFloat32AtomicMinMax ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderBufferFloat16Atomics == rhs.shaderBufferFloat16Atomics ) && - ( shaderBufferFloat16AtomicAdd == rhs.shaderBufferFloat16AtomicAdd ) && - ( shaderBufferFloat16AtomicMinMax == rhs.shaderBufferFloat16AtomicMinMax ) && - ( shaderBufferFloat32AtomicMinMax == rhs.shaderBufferFloat32AtomicMinMax ) && - ( shaderBufferFloat64AtomicMinMax == rhs.shaderBufferFloat64AtomicMinMax ) && - ( shaderSharedFloat16Atomics == rhs.shaderSharedFloat16Atomics ) && - ( shaderSharedFloat16AtomicAdd == rhs.shaderSharedFloat16AtomicAdd ) && - ( shaderSharedFloat16AtomicMinMax == rhs.shaderSharedFloat16AtomicMinMax ) && - ( shaderSharedFloat32AtomicMinMax == rhs.shaderSharedFloat32AtomicMinMax ) && - ( shaderSharedFloat64AtomicMinMax == rhs.shaderSharedFloat64AtomicMinMax ) && - ( shaderImageFloat32AtomicMinMax == rhs.shaderImageFloat32AtomicMinMax ) && - ( sparseImageFloat32AtomicMinMax == rhs.sparseImageFloat32AtomicMinMax ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -62886,48 +59188,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderAtomicFloat2FeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & - physicalDeviceShaderAtomicFloat2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16Atomics ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicAdd ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicMinMax ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat32AtomicMinMax ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat64AtomicMinMax ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16Atomics ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicAdd ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicMinMax ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat32AtomicMinMax ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat64AtomicMinMax ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderImageFloat32AtomicMinMax ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sparseImageFloat32AtomicMinMax ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderAtomicFloatFeaturesEXT { using NativeType = VkPhysicalDeviceShaderAtomicFloatFeaturesEXT; @@ -63076,39 +59336,63 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderBufferFloat32Atomics, + shaderBufferFloat32AtomicAdd, + shaderBufferFloat64Atomics, + shaderBufferFloat64AtomicAdd, + shaderSharedFloat32Atomics, + shaderSharedFloat32AtomicAdd, + shaderSharedFloat64Atomics, + shaderSharedFloat64AtomicAdd, + shaderImageFloat32Atomics, + shaderImageFloat32AtomicAdd, + sparseImageFloat32Atomics, + sparseImageFloat32AtomicAdd ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderBufferFloat32Atomics == rhs.shaderBufferFloat32Atomics ) && - ( shaderBufferFloat32AtomicAdd == rhs.shaderBufferFloat32AtomicAdd ) && - ( shaderBufferFloat64Atomics == rhs.shaderBufferFloat64Atomics ) && - ( shaderBufferFloat64AtomicAdd == rhs.shaderBufferFloat64AtomicAdd ) && - ( shaderSharedFloat32Atomics == rhs.shaderSharedFloat32Atomics ) && - ( shaderSharedFloat32AtomicAdd == rhs.shaderSharedFloat32AtomicAdd ) && - ( shaderSharedFloat64Atomics == rhs.shaderSharedFloat64Atomics ) && - ( shaderSharedFloat64AtomicAdd == rhs.shaderSharedFloat64AtomicAdd ) && - ( shaderImageFloat32Atomics == rhs.shaderImageFloat32Atomics ) && - ( shaderImageFloat32AtomicAdd == rhs.shaderImageFloat32AtomicAdd ) && - ( sparseImageFloat32Atomics == rhs.sparseImageFloat32Atomics ) && - ( sparseImageFloat32AtomicAdd == rhs.sparseImageFloat32AtomicAdd ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -63144,48 +59428,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderAtomicFloatFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT const & - physicalDeviceShaderAtomicFloatFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32Atomics ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32AtomicAdd ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64Atomics ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64AtomicAdd ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32Atomics ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32AtomicAdd ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64Atomics ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64AtomicAdd ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32Atomics ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32AtomicAdd ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32Atomics ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32AtomicAdd ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderAtomicInt64Features { using NativeType = VkPhysicalDeviceShaderAtomicInt64Features; @@ -63243,29 +59485,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceShaderAtomicInt64Features const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderAtomicInt64Features const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderAtomicInt64Features &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderAtomicInt64Features &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderBufferInt64Atomics, shaderSharedInt64Atomics ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderAtomicInt64Features const & ) const = default; #else bool operator==( PhysicalDeviceShaderAtomicInt64Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics ) && - ( shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderAtomicInt64Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -63292,27 +59545,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features const & - physicalDeviceShaderAtomicInt64Features ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderAtomicInt64Features.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderAtomicInt64Features.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderAtomicInt64Features.shaderSharedInt64Atomics ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderClockFeaturesKHR { using NativeType = VkPhysicalDeviceShaderClockFeaturesKHR; @@ -63369,28 +59601,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceShaderClockFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderClockFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderClockFeaturesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderClockFeaturesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderSubgroupClock, shaderDeviceClock ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderClockFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupClock == rhs.shaderSubgroupClock ) && - ( shaderDeviceClock == rhs.shaderDeviceClock ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -63415,27 +59659,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderClockFeaturesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR const & - physicalDeviceShaderClockFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderClockFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderClockFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderClockFeaturesKHR.shaderSubgroupClock ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderClockFeaturesKHR.shaderDeviceClock ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderCoreProperties2AMD { using NativeType = VkPhysicalDeviceShaderCoreProperties2AMD; @@ -63471,28 +59694,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceShaderCoreProperties2AMD const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderCoreProperties2AMD const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderCoreProperties2AMD &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderCoreProperties2AMD &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderCoreFeatures, activeComputeUnitCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderCoreProperties2AMD const & ) const = default; #else bool operator==( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCoreFeatures == rhs.shaderCoreFeatures ) && - ( activeComputeUnitCount == rhs.activeComputeUnitCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -63518,27 +59753,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderCoreProperties2AMD; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD const & - physicalDeviceShaderCoreProperties2AMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderCoreProperties2AMD.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderCoreProperties2AMD.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderCorePropertiesFlagsAMD, - seed, - physicalDeviceShaderCoreProperties2AMD.shaderCoreFeatures ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCoreProperties2AMD.activeComputeUnitCount ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderCorePropertiesAMD { using NativeType = VkPhysicalDeviceShaderCorePropertiesAMD; @@ -63598,35 +59812,67 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceShaderCorePropertiesAMD const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderCorePropertiesAMD const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderCorePropertiesAMD &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderCorePropertiesAMD &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderEngineCount, + shaderArraysPerEngineCount, + computeUnitsPerShaderArray, + simdPerComputeUnit, + wavefrontsPerSimd, + wavefrontSize, + sgprsPerSimd, + minSgprAllocation, + maxSgprAllocation, + sgprAllocationGranularity, + vgprsPerSimd, + minVgprAllocation, + maxVgprAllocation, + vgprAllocationGranularity ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderCorePropertiesAMD const & ) const = default; #else bool operator==( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderEngineCount == rhs.shaderEngineCount ) && - ( shaderArraysPerEngineCount == rhs.shaderArraysPerEngineCount ) && - ( computeUnitsPerShaderArray == rhs.computeUnitsPerShaderArray ) && - ( simdPerComputeUnit == rhs.simdPerComputeUnit ) && ( wavefrontsPerSimd == rhs.wavefrontsPerSimd ) && - ( wavefrontSize == rhs.wavefrontSize ) && ( sgprsPerSimd == rhs.sgprsPerSimd ) && - ( minSgprAllocation == rhs.minSgprAllocation ) && ( maxSgprAllocation == rhs.maxSgprAllocation ) && - ( sgprAllocationGranularity == rhs.sgprAllocationGranularity ) && ( vgprsPerSimd == rhs.vgprsPerSimd ) && - ( minVgprAllocation == rhs.minVgprAllocation ) && ( maxVgprAllocation == rhs.maxVgprAllocation ) && - ( vgprAllocationGranularity == rhs.vgprAllocationGranularity ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -63663,37 +59909,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderCorePropertiesAMD; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD const & - physicalDeviceShaderCorePropertiesAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderCorePropertiesAMD.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderCorePropertiesAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.shaderEngineCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.shaderArraysPerEngineCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.computeUnitsPerShaderArray ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.simdPerComputeUnit ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.wavefrontsPerSimd ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.wavefrontSize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.sgprsPerSimd ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.minSgprAllocation ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.maxSgprAllocation ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.sgprAllocationGranularity ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.vgprsPerSimd ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.minVgprAllocation ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.maxVgprAllocation ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderCorePropertiesAMD.vgprAllocationGranularity ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT { using NativeType = VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; @@ -63745,28 +59960,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderDemoteToHelperInvocation ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderDemoteToHelperInvocation == rhs.shaderDemoteToHelperInvocation ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -63792,27 +60016,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & - physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.shaderDemoteToHelperInvocation ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderDrawParametersFeatures { using NativeType = VkPhysicalDeviceShaderDrawParametersFeatures; @@ -63862,27 +60065,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceShaderDrawParametersFeatures const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderDrawParametersFeatures const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderDrawParametersFeatures &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderDrawParametersFeatures &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderDrawParameters ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderDrawParametersFeatures const & ) const = default; #else bool operator==( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderDrawParameters == rhs.shaderDrawParameters ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -63908,26 +60121,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures const & - physicalDeviceShaderDrawParametersFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderDrawParametersFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderDrawParametersFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderDrawParametersFeatures.shaderDrawParameters ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderFloat16Int8Features { using NativeType = VkPhysicalDeviceShaderFloat16Int8Features; @@ -63985,28 +60178,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceShaderFloat16Int8Features const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderFloat16Int8Features const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderFloat16Int8Features &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderFloat16Int8Features &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderFloat16, shaderInt8 ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderFloat16Int8Features const & ) const = default; #else bool operator==( PhysicalDeviceShaderFloat16Int8Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFloat16 == rhs.shaderFloat16 ) && - ( shaderInt8 == rhs.shaderInt8 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderFloat16Int8Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -64034,26 +60239,6 @@ namespace VULKAN_HPP_NAMESPACE using PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features; using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features const & - physicalDeviceShaderFloat16Int8Features ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderFloat16Int8Features.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderFloat16Int8Features.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderFloat16Int8Features.shaderFloat16 ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderFloat16Int8Features.shaderInt8 ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { using NativeType = VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT; @@ -64113,29 +60298,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderImageInt64Atomics, sparseImageInt64Atomics ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderImageInt64Atomics == rhs.shaderImageInt64Atomics ) && - ( sparseImageInt64Atomics == rhs.sparseImageInt64Atomics ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -64161,28 +60357,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderImageAtomicInt64FeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & - physicalDeviceShaderImageAtomicInt64FeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.shaderImageInt64Atomics ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sparseImageInt64Atomics ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderImageFootprintFeaturesNV { using NativeType = VkPhysicalDeviceShaderImageFootprintFeaturesNV; @@ -64231,27 +60405,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceShaderImageFootprintFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderImageFootprintFeaturesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderImageFootprintFeaturesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderImageFootprintFeaturesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageFootprint ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderImageFootprintFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageFootprint == rhs.imageFootprint ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -64276,26 +60460,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderImageFootprintFeaturesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV const & - physicalDeviceShaderImageFootprintFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderImageFootprintFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderImageFootprintFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderImageFootprintFeaturesNV.imageFootprint ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderIntegerDotProductFeaturesKHR { using NativeType = VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR; @@ -64346,28 +60510,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderIntegerDotProduct ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderIntegerDotProduct == rhs.shaderIntegerDotProduct ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -64392,26 +60565,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderIntegerDotProductFeaturesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & - physicalDeviceShaderIntegerDotProductFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderIntegerDotProductFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderIntegerDotProductFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderIntegerDotProductFeaturesKHR.shaderIntegerDotProduct ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderIntegerDotProductPropertiesKHR { using NativeType = VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR; @@ -64801,78 +60954,99 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + integerDotProduct8BitUnsignedAccelerated, + integerDotProduct8BitSignedAccelerated, + integerDotProduct8BitMixedSignednessAccelerated, + integerDotProduct4x8BitPackedUnsignedAccelerated, + integerDotProduct4x8BitPackedSignedAccelerated, + integerDotProduct4x8BitPackedMixedSignednessAccelerated, + integerDotProduct16BitUnsignedAccelerated, + integerDotProduct16BitSignedAccelerated, + integerDotProduct16BitMixedSignednessAccelerated, + integerDotProduct32BitUnsignedAccelerated, + integerDotProduct32BitSignedAccelerated, + integerDotProduct32BitMixedSignednessAccelerated, + integerDotProduct64BitUnsignedAccelerated, + integerDotProduct64BitSignedAccelerated, + integerDotProduct64BitMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, + integerDotProductAccumulatingSaturating8BitSignedAccelerated, + integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, + integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, + integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, + integerDotProductAccumulatingSaturating16BitSignedAccelerated, + integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, + integerDotProductAccumulatingSaturating32BitSignedAccelerated, + integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, + integerDotProductAccumulatingSaturating64BitSignedAccelerated, + integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & ) const = default; #else bool operator==( PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( integerDotProduct8BitUnsignedAccelerated == rhs.integerDotProduct8BitUnsignedAccelerated ) && - ( integerDotProduct8BitSignedAccelerated == rhs.integerDotProduct8BitSignedAccelerated ) && - ( integerDotProduct8BitMixedSignednessAccelerated == - rhs.integerDotProduct8BitMixedSignednessAccelerated ) && - ( integerDotProduct4x8BitPackedUnsignedAccelerated == - rhs.integerDotProduct4x8BitPackedUnsignedAccelerated ) && - ( integerDotProduct4x8BitPackedSignedAccelerated == rhs.integerDotProduct4x8BitPackedSignedAccelerated ) && - ( integerDotProduct4x8BitPackedMixedSignednessAccelerated == - rhs.integerDotProduct4x8BitPackedMixedSignednessAccelerated ) && - ( integerDotProduct16BitUnsignedAccelerated == rhs.integerDotProduct16BitUnsignedAccelerated ) && - ( integerDotProduct16BitSignedAccelerated == rhs.integerDotProduct16BitSignedAccelerated ) && - ( integerDotProduct16BitMixedSignednessAccelerated == - rhs.integerDotProduct16BitMixedSignednessAccelerated ) && - ( integerDotProduct32BitUnsignedAccelerated == rhs.integerDotProduct32BitUnsignedAccelerated ) && - ( integerDotProduct32BitSignedAccelerated == rhs.integerDotProduct32BitSignedAccelerated ) && - ( integerDotProduct32BitMixedSignednessAccelerated == - rhs.integerDotProduct32BitMixedSignednessAccelerated ) && - ( integerDotProduct64BitUnsignedAccelerated == rhs.integerDotProduct64BitUnsignedAccelerated ) && - ( integerDotProduct64BitSignedAccelerated == rhs.integerDotProduct64BitSignedAccelerated ) && - ( integerDotProduct64BitMixedSignednessAccelerated == - rhs.integerDotProduct64BitMixedSignednessAccelerated ) && - ( integerDotProductAccumulatingSaturating8BitUnsignedAccelerated == - rhs.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ) && - ( integerDotProductAccumulatingSaturating8BitSignedAccelerated == - rhs.integerDotProductAccumulatingSaturating8BitSignedAccelerated ) && - ( integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated == - rhs.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ) && - ( integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated == - rhs.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ) && - ( integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated == - rhs.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ) && - ( integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated == - rhs.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ) && - ( integerDotProductAccumulatingSaturating16BitUnsignedAccelerated == - rhs.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ) && - ( integerDotProductAccumulatingSaturating16BitSignedAccelerated == - rhs.integerDotProductAccumulatingSaturating16BitSignedAccelerated ) && - ( integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated == - rhs.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ) && - ( integerDotProductAccumulatingSaturating32BitUnsignedAccelerated == - rhs.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ) && - ( integerDotProductAccumulatingSaturating32BitSignedAccelerated == - rhs.integerDotProductAccumulatingSaturating32BitSignedAccelerated ) && - ( integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated == - rhs.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ) && - ( integerDotProductAccumulatingSaturating64BitUnsignedAccelerated == - rhs.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ) && - ( integerDotProductAccumulatingSaturating64BitSignedAccelerated == - rhs.integerDotProductAccumulatingSaturating64BitSignedAccelerated ) && - ( integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated == - rhs.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -64926,144 +61100,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderIntegerDotProductPropertiesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & - physicalDeviceShaderIntegerDotProductPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderIntegerDotProductPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderIntegerDotProductPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct8BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct8BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct8BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct4x8BitPackedUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct4x8BitPackedSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct4x8BitPackedMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct16BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct16BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct16BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct32BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct32BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct32BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct64BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct64BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProduct64BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR - .integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR.integerDotProductAccumulatingSaturating8BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR - .integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR - .integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR - .integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR - .integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR - .integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR - .integerDotProductAccumulatingSaturating16BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR - .integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR - .integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR - .integerDotProductAccumulatingSaturating32BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR - .integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR - .integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR - .integerDotProductAccumulatingSaturating64BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderIntegerDotProductPropertiesKHR - .integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { using NativeType = VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; @@ -65115,28 +61151,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderIntegerFunctions2 ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & ) const = default; #else bool operator==( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderIntegerFunctions2 == rhs.shaderIntegerFunctions2 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -65161,26 +61206,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & - physicalDeviceShaderIntegerFunctions2FeaturesINTEL ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.shaderIntegerFunctions2 ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderSMBuiltinsFeaturesNV { using NativeType = VkPhysicalDeviceShaderSMBuiltinsFeaturesNV; @@ -65229,27 +61254,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderSMBuiltins ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSMBuiltins == rhs.shaderSMBuiltins ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -65274,26 +61309,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderSMBuiltinsFeaturesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV const & - physicalDeviceShaderSMBuiltinsFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderSMBuiltinsFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderSMBuiltinsFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShaderSMBuiltinsFeaturesNV.shaderSMBuiltins ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderSMBuiltinsPropertiesNV { using NativeType = VkPhysicalDeviceShaderSMBuiltinsPropertiesNV; @@ -65330,28 +61345,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderSMCount, shaderWarpsPerSM ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSMCount == rhs.shaderSMCount ) && - ( shaderWarpsPerSM == rhs.shaderWarpsPerSM ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -65377,26 +61401,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderSMBuiltinsPropertiesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV const & - physicalDeviceShaderSMBuiltinsPropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderSMBuiltinsPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderSMBuiltinsPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderSMCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderWarpsPerSM ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures { using NativeType = VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures; @@ -65448,28 +61452,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderSubgroupExtendedTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & ) const = default; #else bool operator==( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderSubgroupExtendedTypes == rhs.shaderSubgroupExtendedTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -65495,27 +61508,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & - physicalDeviceShaderSubgroupExtendedTypesFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderSubgroupExtendedTypesFeatures.shaderSubgroupExtendedTypes ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { using NativeType = VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; @@ -65569,28 +61561,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderSubgroupUniformControlFlow ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderSubgroupUniformControlFlow == rhs.shaderSubgroupUniformControlFlow ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -65617,28 +61618,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & - physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.shaderSubgroupUniformControlFlow ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShaderTerminateInvocationFeaturesKHR { using NativeType = VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR; @@ -65690,28 +61669,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderTerminateInvocation ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderTerminateInvocation == rhs.shaderTerminateInvocation ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -65736,27 +61724,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderTerminateInvocationFeaturesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & - physicalDeviceShaderTerminateInvocationFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShaderTerminateInvocationFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShaderTerminateInvocationFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceShaderTerminateInvocationFeaturesKHR.shaderTerminateInvocation ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShadingRateImageFeaturesNV { using NativeType = VkPhysicalDeviceShadingRateImageFeaturesNV; @@ -65815,28 +61782,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceShadingRateImageFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShadingRateImageFeaturesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShadingRateImageFeaturesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShadingRateImageFeaturesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shadingRateImage, shadingRateCoarseSampleOrder ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShadingRateImageFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateImage == rhs.shadingRateImage ) && - ( shadingRateCoarseSampleOrder == rhs.shadingRateCoarseSampleOrder ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -65862,28 +61841,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShadingRateImageFeaturesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV const & - physicalDeviceShadingRateImageFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShadingRateImageFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShadingRateImageFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateImage ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateCoarseSampleOrder ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceShadingRateImagePropertiesNV { using NativeType = VkPhysicalDeviceShadingRateImagePropertiesNV; @@ -65922,29 +61879,41 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceShadingRateImagePropertiesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShadingRateImagePropertiesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceShadingRateImagePropertiesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceShadingRateImagePropertiesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shadingRateTexelSize, shadingRatePaletteSize, shadingRateMaxCoarseSamples ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShadingRateImagePropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateTexelSize == rhs.shadingRateTexelSize ) && - ( shadingRatePaletteSize == rhs.shadingRatePaletteSize ) && - ( shadingRateMaxCoarseSamples == rhs.shadingRateMaxCoarseSamples ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -65971,28 +61940,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShadingRateImagePropertiesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV const & - physicalDeviceShadingRateImagePropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceShadingRateImagePropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceShadingRateImagePropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Extent2D, seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateTexelSize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShadingRateImagePropertiesNV.shadingRatePaletteSize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateMaxCoarseSamples ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceSparseImageFormatInfo2 { using NativeType = VkPhysicalDeviceSparseImageFormatInfo2; @@ -66076,28 +62023,43 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceSparseImageFormatInfo2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSparseImageFormatInfo2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceSparseImageFormatInfo2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSparseImageFormatInfo2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, format, type, samples, usage, tiling ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSparseImageFormatInfo2 const & ) const = default; #else bool operator==( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( type == rhs.type ) && - ( samples == rhs.samples ) && ( usage == rhs.usage ) && ( tiling == rhs.tiling ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -66126,29 +62088,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 const & - physicalDeviceSparseImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSparseImageFormatInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceSparseImageFormatInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, physicalDeviceSparseImageFormatInfo2.format ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageType, seed, physicalDeviceSparseImageFormatInfo2.type ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleCountFlagBits, seed, physicalDeviceSparseImageFormatInfo2.samples ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, physicalDeviceSparseImageFormatInfo2.usage ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageTiling, seed, physicalDeviceSparseImageFormatInfo2.tiling ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceSubgroupProperties { using NativeType = VkPhysicalDeviceSubgroupProperties; @@ -66185,29 +62124,42 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceSubgroupProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSubgroupProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceSubgroupProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSubgroupProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, subgroupSize, supportedStages, supportedOperations, quadOperationsInAllStages ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSubgroupProperties const & ) const = default; #else bool operator==( PhysicalDeviceSubgroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subgroupSize == rhs.subgroupSize ) && - ( supportedStages == rhs.supportedStages ) && ( supportedOperations == rhs.supportedOperations ) && - ( quadOperationsInAllStages == rhs.quadOperationsInAllStages ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSubgroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -66234,31 +62186,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceSubgroupProperties; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties const & physicalDeviceSubgroupProperties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubgroupProperties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubgroupProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceSubgroupProperties.subgroupSize ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, physicalDeviceSubgroupProperties.supportedStages ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags, seed, physicalDeviceSubgroupProperties.supportedOperations ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSubgroupProperties.quadOperationsInAllStages ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceSubgroupSizeControlFeaturesEXT { using NativeType = VkPhysicalDeviceSubgroupSizeControlFeaturesEXT; @@ -66317,28 +62244,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, subgroupSizeControl, computeFullSubgroups ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subgroupSizeControl == rhs.subgroupSizeControl ) && - ( computeFullSubgroups == rhs.computeFullSubgroups ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -66364,28 +62303,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceSubgroupSizeControlFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeaturesEXT const & - physicalDeviceSubgroupSizeControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubgroupSizeControlFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubgroupSizeControlFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSubgroupSizeControlFeaturesEXT.subgroupSizeControl ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSubgroupSizeControlFeaturesEXT.computeFullSubgroups ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceSubgroupSizeControlPropertiesEXT { using NativeType = VkPhysicalDeviceSubgroupSizeControlPropertiesEXT; @@ -66426,30 +62343,43 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceSubgroupSizeControlPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSubgroupSizeControlPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, minSubgroupSize, maxSubgroupSize, maxComputeWorkgroupSubgroups, requiredSubgroupSizeStages ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minSubgroupSize == rhs.minSubgroupSize ) && - ( maxSubgroupSize == rhs.maxSubgroupSize ) && - ( maxComputeWorkgroupSubgroups == rhs.maxComputeWorkgroupSubgroups ) && - ( requiredSubgroupSizeStages == rhs.requiredSubgroupSizeStages ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -66477,31 +62407,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceSubgroupSizeControlPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlPropertiesEXT const & - physicalDeviceSubgroupSizeControlPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.minSubgroupSize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.maxSubgroupSize ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceSubgroupSizeControlPropertiesEXT.maxComputeWorkgroupSubgroups ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags, - seed, - physicalDeviceSubgroupSizeControlPropertiesEXT.requiredSubgroupSizeStages ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceSubpassShadingFeaturesHUAWEI { using NativeType = VkPhysicalDeviceSubpassShadingFeaturesHUAWEI; @@ -66550,27 +62455,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, subpassShading ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & ) const = default; #else bool operator==( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassShading == rhs.subpassShading ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -66595,26 +62510,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceSubpassShadingFeaturesHUAWEI; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI const & - physicalDeviceSubpassShadingFeaturesHUAWEI ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubpassShadingFeaturesHUAWEI.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubpassShadingFeaturesHUAWEI.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSubpassShadingFeaturesHUAWEI.subpassShading ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceSubpassShadingPropertiesHUAWEI { using NativeType = VkPhysicalDeviceSubpassShadingPropertiesHUAWEI; @@ -66649,28 +62544,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxSubpassShadingWorkgroupSizeAspectRatio ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & ) const = default; #else bool operator==( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxSubpassShadingWorkgroupSizeAspectRatio == rhs.maxSubpassShadingWorkgroupSizeAspectRatio ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -66695,26 +62599,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceSubpassShadingPropertiesHUAWEI; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI const & - physicalDeviceSubpassShadingPropertiesHUAWEI ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSubpassShadingPropertiesHUAWEI.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSubpassShadingPropertiesHUAWEI.pNext ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceSubpassShadingPropertiesHUAWEI.maxSubpassShadingWorkgroupSizeAspectRatio ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceSurfaceInfo2KHR { using NativeType = VkPhysicalDeviceSurfaceInfo2KHR; @@ -66760,27 +62644,38 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceSurfaceInfo2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSurfaceInfo2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceSurfaceInfo2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSurfaceInfo2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std:: + tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, surface ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSurfaceInfo2KHR const & ) const = default; #else bool operator==( PhysicalDeviceSurfaceInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surface == rhs.surface ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSurfaceInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -66804,24 +62699,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceSurfaceInfo2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR const & physicalDeviceSurfaceInfo2KHR ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSurfaceInfo2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, physicalDeviceSurfaceInfo2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SurfaceKHR, seed, physicalDeviceSurfaceInfo2KHR.surface ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceSynchronization2FeaturesKHR { using NativeType = VkPhysicalDeviceSynchronization2FeaturesKHR; @@ -66870,27 +62747,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceSynchronization2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSynchronization2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceSynchronization2FeaturesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceSynchronization2FeaturesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, synchronization2 ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSynchronization2FeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceSynchronization2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( synchronization2 == rhs.synchronization2 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSynchronization2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -66915,26 +62802,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceSynchronization2FeaturesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2FeaturesKHR const & - physicalDeviceSynchronization2FeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceSynchronization2FeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceSynchronization2FeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceSynchronization2FeaturesKHR.synchronization2 ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT { using NativeType = VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT; @@ -66985,27 +62852,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, texelBufferAlignment ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( texelBufferAlignment == rhs.texelBufferAlignment ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -67030,26 +62907,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceTexelBufferAlignmentFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & - physicalDeviceTexelBufferAlignmentFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.texelBufferAlignment ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT { using NativeType = VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT; @@ -67090,31 +62947,47 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + storageTexelBufferOffsetAlignmentBytes, + storageTexelBufferOffsetSingleTexelAlignment, + uniformTexelBufferOffsetAlignmentBytes, + uniformTexelBufferOffsetSingleTexelAlignment ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( storageTexelBufferOffsetAlignmentBytes == rhs.storageTexelBufferOffsetAlignmentBytes ) && - ( storageTexelBufferOffsetSingleTexelAlignment == rhs.storageTexelBufferOffsetSingleTexelAlignment ) && - ( uniformTexelBufferOffsetAlignmentBytes == rhs.uniformTexelBufferOffsetAlignmentBytes ) && - ( uniformTexelBufferOffsetSingleTexelAlignment == rhs.uniformTexelBufferOffsetSingleTexelAlignment ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -67142,38 +63015,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceTexelBufferAlignmentPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & - physicalDeviceTexelBufferAlignmentPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTexelBufferAlignmentPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTexelBufferAlignmentPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, - seed, - physicalDeviceTexelBufferAlignmentPropertiesEXT.storageTexelBufferOffsetAlignmentBytes ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceTexelBufferAlignmentPropertiesEXT.storageTexelBufferOffsetSingleTexelAlignment ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, - seed, - physicalDeviceTexelBufferAlignmentPropertiesEXT.uniformTexelBufferOffsetAlignmentBytes ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceTexelBufferAlignmentPropertiesEXT.uniformTexelBufferOffsetSingleTexelAlignment ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT { using NativeType = VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT; @@ -67225,28 +63066,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, textureCompressionASTC_HDR ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( textureCompressionASTC_HDR == rhs.textureCompressionASTC_HDR ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -67271,27 +63121,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & - physicalDeviceTextureCompressionASTCHDRFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTextureCompressionASTCHDRFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTextureCompressionASTCHDRFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceTextureCompressionASTCHDRFeaturesEXT.textureCompressionASTC_HDR ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceTimelineSemaphoreFeatures { using NativeType = VkPhysicalDeviceTimelineSemaphoreFeatures; @@ -67339,27 +63168,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceTimelineSemaphoreFeatures const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceTimelineSemaphoreFeatures const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceTimelineSemaphoreFeatures &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceTimelineSemaphoreFeatures &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, timelineSemaphore ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTimelineSemaphoreFeatures const & ) const = default; #else bool operator==( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timelineSemaphore == rhs.timelineSemaphore ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -67385,25 +63224,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures const & - physicalDeviceTimelineSemaphoreFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTimelineSemaphoreFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTimelineSemaphoreFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTimelineSemaphoreFeatures.timelineSemaphore ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceTimelineSemaphoreProperties { using NativeType = VkPhysicalDeviceTimelineSemaphoreProperties; @@ -67437,28 +63257,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceTimelineSemaphoreProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceTimelineSemaphoreProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceTimelineSemaphoreProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceTimelineSemaphoreProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxTimelineSemaphoreValueDifference ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTimelineSemaphoreProperties const & ) const = default; #else bool operator==( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxTimelineSemaphoreValueDifference == rhs.maxTimelineSemaphoreValueDifference ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -67484,26 +63313,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties const & - physicalDeviceTimelineSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTimelineSemaphoreProperties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTimelineSemaphoreProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( - uint64_t, seed, physicalDeviceTimelineSemaphoreProperties.maxTimelineSemaphoreValueDifference ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceToolPropertiesEXT { using NativeType = VkPhysicalDeviceToolPropertiesEXT; @@ -67542,28 +63351,43 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceToolPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceToolPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceToolPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceToolPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::ToolPurposeFlagsEXT const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, name, version, purposes, description, layer ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceToolPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceToolPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( name == rhs.name ) && ( version == rhs.version ) && - ( purposes == rhs.purposes ) && ( description == rhs.description ) && ( layer == rhs.layer ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceToolPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -67591,42 +63415,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceToolPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT const & physicalDeviceToolPropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceToolPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceToolPropertiesEXT.pNext ); - for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceToolPropertiesEXT.name[i] ); - } - for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceToolPropertiesEXT.version[i] ); - } - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ToolPurposeFlagsEXT, seed, physicalDeviceToolPropertiesEXT.purposes ); - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceToolPropertiesEXT.description[i] ); - } - for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceToolPropertiesEXT.layer[i] ); - } - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceTransformFeedbackFeaturesEXT { using NativeType = VkPhysicalDeviceTransformFeedbackFeaturesEXT; @@ -67685,28 +63473,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceTransformFeedbackFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceTransformFeedbackFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceTransformFeedbackFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceTransformFeedbackFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, transformFeedback, geometryStreams ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTransformFeedbackFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transformFeedback == rhs.transformFeedback ) && - ( geometryStreams == rhs.geometryStreams ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -67732,28 +63532,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceTransformFeedbackFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT const & - physicalDeviceTransformFeedbackFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTransformFeedbackFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTransformFeedbackFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTransformFeedbackFeaturesEXT.transformFeedback ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTransformFeedbackFeaturesEXT.geometryStreams ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceTransformFeedbackPropertiesEXT { using NativeType = VkPhysicalDeviceTransformFeedbackPropertiesEXT; @@ -67806,37 +63584,59 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceTransformFeedbackPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceTransformFeedbackPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceTransformFeedbackPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceTransformFeedbackPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxTransformFeedbackStreams, + maxTransformFeedbackBuffers, + maxTransformFeedbackBufferSize, + maxTransformFeedbackStreamDataSize, + maxTransformFeedbackBufferDataSize, + maxTransformFeedbackBufferDataStride, + transformFeedbackQueries, + transformFeedbackStreamsLinesTriangles, + transformFeedbackRasterizationStreamSelect, + transformFeedbackDraw ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTransformFeedbackPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxTransformFeedbackStreams == rhs.maxTransformFeedbackStreams ) && - ( maxTransformFeedbackBuffers == rhs.maxTransformFeedbackBuffers ) && - ( maxTransformFeedbackBufferSize == rhs.maxTransformFeedbackBufferSize ) && - ( maxTransformFeedbackStreamDataSize == rhs.maxTransformFeedbackStreamDataSize ) && - ( maxTransformFeedbackBufferDataSize == rhs.maxTransformFeedbackBufferDataSize ) && - ( maxTransformFeedbackBufferDataStride == rhs.maxTransformFeedbackBufferDataStride ) && - ( transformFeedbackQueries == rhs.transformFeedbackQueries ) && - ( transformFeedbackStreamsLinesTriangles == rhs.transformFeedbackStreamsLinesTriangles ) && - ( transformFeedbackRasterizationStreamSelect == rhs.transformFeedbackRasterizationStreamSelect ) && - ( transformFeedbackDraw == rhs.transformFeedbackDraw ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -67870,45 +63670,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceTransformFeedbackPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT const & - physicalDeviceTransformFeedbackPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceTransformFeedbackPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceTransformFeedbackPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreams ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBuffers ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, - seed, - physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferSize ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreamDataSize ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataSize ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataStride ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackQueries ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackStreamsLinesTriangles ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackRasterizationStreamSelect ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackDraw ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceUniformBufferStandardLayoutFeatures { using NativeType = VkPhysicalDeviceUniformBufferStandardLayoutFeatures; @@ -67960,28 +63721,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, uniformBufferStandardLayout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceUniformBufferStandardLayoutFeatures const & ) const = default; #else bool operator==( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( uniformBufferStandardLayout == rhs.uniformBufferStandardLayout ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -68007,27 +63777,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures const & - physicalDeviceUniformBufferStandardLayoutFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceUniformBufferStandardLayoutFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceUniformBufferStandardLayoutFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceUniformBufferStandardLayoutFeatures.uniformBufferStandardLayout ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceVariablePointersFeatures { using NativeType = VkPhysicalDeviceVariablePointersFeatures; @@ -68085,29 +63834,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceVariablePointersFeatures const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVariablePointersFeatures const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceVariablePointersFeatures &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVariablePointersFeatures &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, variablePointersStorageBuffer, variablePointers ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVariablePointersFeatures const & ) const = default; #else bool operator==( PhysicalDeviceVariablePointersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) && - ( variablePointers == rhs.variablePointers ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVariablePointersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -68136,27 +63896,6 @@ namespace VULKAN_HPP_NAMESPACE using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures; using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures const & - physicalDeviceVariablePointersFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVariablePointersFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVariablePointersFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVariablePointersFeatures.variablePointersStorageBuffer ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVariablePointersFeatures.variablePointers ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT { using NativeType = VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT; @@ -68216,29 +63955,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vertexAttributeInstanceRateDivisor, vertexAttributeInstanceRateZeroDivisor ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( vertexAttributeInstanceRateDivisor == rhs.vertexAttributeInstanceRateDivisor ) && - ( vertexAttributeInstanceRateZeroDivisor == rhs.vertexAttributeInstanceRateZeroDivisor ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -68264,30 +64014,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceVertexAttributeDivisorFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & - physicalDeviceVertexAttributeDivisorFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateDivisor ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateZeroDivisor ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT { using NativeType = VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; @@ -68323,28 +64049,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxVertexAttribDivisor ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxVertexAttribDivisor == rhs.maxVertexAttribDivisor ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -68369,25 +64104,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceVertexAttributeDivisorPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & - physicalDeviceVertexAttributeDivisorPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.maxVertexAttribDivisor ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT { using NativeType = VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT; @@ -68438,28 +64154,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vertexInputDynamicState ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( vertexInputDynamicState == rhs.vertexInputDynamicState ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -68484,26 +64209,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceVertexInputDynamicStateFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & - physicalDeviceVertexInputDynamicStateFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.vertexInputDynamicState ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_ENABLE_BETA_EXTENSIONS ) struct VideoProfileKHR { @@ -68576,29 +64281,42 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoProfileKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoProfileKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoProfileKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoProfileKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, videoCodecOperation, chromaSubsampling, lumaBitDepth, chromaBitDepth ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoProfileKHR const & ) const = default; # else bool operator==( VideoProfileKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperation == rhs.videoCodecOperation ) && - ( chromaSubsampling == rhs.chromaSubsampling ) && ( lumaBitDepth == rhs.lumaBitDepth ) && - ( chromaBitDepth == rhs.chromaBitDepth ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoProfileKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -68623,30 +64341,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoProfileKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileKHR const & videoProfileKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoProfileKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, videoProfileKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR, seed, videoProfileKHR.videoCodecOperation ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR, seed, videoProfileKHR.chromaSubsampling ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR, seed, videoProfileKHR.lumaBitDepth ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR, seed, videoProfileKHR.chromaBitDepth ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -68701,28 +64395,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoProfilesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoProfilesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoProfilesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoProfilesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, profileCount, pProfiles ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoProfilesKHR const & ) const = default; # else bool operator==( VideoProfilesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( profileCount == rhs.profileCount ) && - ( pProfiles == rhs.pProfiles ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoProfilesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -68744,25 +64450,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoProfilesKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfilesKHR const & videoProfilesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoProfilesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, videoProfilesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoProfilesKHR.profileCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoProfileKHR *, seed, videoProfilesKHR.pProfiles ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -68798,28 +64485,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceVideoFormatInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVideoFormatInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceVideoFormatInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVideoFormatInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageUsage, pVideoProfiles ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVideoFormatInfoKHR const & ) const = default; # else bool operator==( PhysicalDeviceVideoFormatInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageUsage == rhs.imageUsage ) && - ( pVideoProfiles == rhs.pVideoProfiles ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVideoFormatInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -68843,28 +64542,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = PhysicalDeviceVideoFormatInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR const & physicalDeviceVideoFormatInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVideoFormatInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVideoFormatInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, physicalDeviceVideoFormatInfoKHR.imageUsage ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::VideoProfilesKHR *, seed, physicalDeviceVideoFormatInfoKHR.pVideoProfiles ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct PhysicalDeviceVulkan11Features @@ -69011,37 +64688,63 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceVulkan11Features const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVulkan11Features const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceVulkan11Features &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVulkan11Features &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + storageBuffer16BitAccess, + uniformAndStorageBuffer16BitAccess, + storagePushConstant16, + storageInputOutput16, + multiview, + multiviewGeometryShader, + multiviewTessellationShader, + variablePointersStorageBuffer, + variablePointers, + protectedMemory, + samplerYcbcrConversion, + shaderDrawParameters ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVulkan11Features const & ) const = default; #else bool operator==( PhysicalDeviceVulkan11Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) && - ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) && - ( storagePushConstant16 == rhs.storagePushConstant16 ) && - ( storageInputOutput16 == rhs.storageInputOutput16 ) && ( multiview == rhs.multiview ) && - ( multiviewGeometryShader == rhs.multiviewGeometryShader ) && - ( multiviewTessellationShader == rhs.multiviewTessellationShader ) && - ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) && - ( variablePointers == rhs.variablePointers ) && ( protectedMemory == rhs.protectedMemory ) && - ( samplerYcbcrConversion == rhs.samplerYcbcrConversion ) && - ( shaderDrawParameters == rhs.shaderDrawParameters ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVulkan11Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -69076,41 +64779,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceVulkan11Features; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features const & physicalDeviceVulkan11Features ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkan11Features.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkan11Features.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.storageBuffer16BitAccess ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.uniformAndStorageBuffer16BitAccess ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.storagePushConstant16 ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.storageInputOutput16 ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.multiview ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.multiviewGeometryShader ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.multiviewTessellationShader ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.variablePointersStorageBuffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.variablePointers ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.protectedMemory ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.samplerYcbcrConversion ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Features.shaderDrawParameters ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceVulkan11Properties { using NativeType = VkPhysicalDeviceVulkan11Properties; @@ -69170,37 +64838,69 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceVulkan11Properties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVulkan11Properties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceVulkan11Properties &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVulkan11Properties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::ShaderStageFlags const &, + VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::PointClippingBehavior const &, + uint32_t const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::DeviceSize const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + deviceUUID, + driverUUID, + deviceLUID, + deviceNodeMask, + deviceLUIDValid, + subgroupSize, + subgroupSupportedStages, + subgroupSupportedOperations, + subgroupQuadOperationsInAllStages, + pointClippingBehavior, + maxMultiviewViewCount, + maxMultiviewInstanceIndex, + protectedNoFault, + maxPerSetDescriptors, + maxMemoryAllocationSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVulkan11Properties const & ) const = default; #else bool operator==( PhysicalDeviceVulkan11Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceUUID == rhs.deviceUUID ) && - ( driverUUID == rhs.driverUUID ) && ( deviceLUID == rhs.deviceLUID ) && - ( deviceNodeMask == rhs.deviceNodeMask ) && ( deviceLUIDValid == rhs.deviceLUIDValid ) && - ( subgroupSize == rhs.subgroupSize ) && ( subgroupSupportedStages == rhs.subgroupSupportedStages ) && - ( subgroupSupportedOperations == rhs.subgroupSupportedOperations ) && - ( subgroupQuadOperationsInAllStages == rhs.subgroupQuadOperationsInAllStages ) && - ( pointClippingBehavior == rhs.pointClippingBehavior ) && - ( maxMultiviewViewCount == rhs.maxMultiviewViewCount ) && - ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex ) && - ( protectedNoFault == rhs.protectedNoFault ) && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors ) && - ( maxMemoryAllocationSize == rhs.maxMemoryAllocationSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVulkan11Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -69239,53 +64939,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceVulkan11Properties; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties const & physicalDeviceVulkan11Properties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkan11Properties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkan11Properties.pNext ); - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceVulkan11Properties.deviceUUID[i] ); - } - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceVulkan11Properties.driverUUID[i] ); - } - for ( size_t i = 0; i < VK_LUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, physicalDeviceVulkan11Properties.deviceLUID[i] ); - } - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.deviceNodeMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Properties.deviceLUIDValid ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.subgroupSize ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, physicalDeviceVulkan11Properties.subgroupSupportedStages ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags, seed, physicalDeviceVulkan11Properties.subgroupSupportedOperations ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Properties.subgroupQuadOperationsInAllStages ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PointClippingBehavior, seed, physicalDeviceVulkan11Properties.pointClippingBehavior ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.maxMultiviewViewCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.maxMultiviewInstanceIndex ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan11Properties.protectedNoFault ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan11Properties.maxPerSetDescriptors ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceSize, seed, physicalDeviceVulkan11Properties.maxMemoryAllocationSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceVulkan12Features { using NativeType = VkPhysicalDeviceVulkan12Features; @@ -69745,74 +65398,133 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceVulkan12Features const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVulkan12Features const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceVulkan12Features &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVulkan12Features &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + samplerMirrorClampToEdge, + drawIndirectCount, + storageBuffer8BitAccess, + uniformAndStorageBuffer8BitAccess, + storagePushConstant8, + shaderBufferInt64Atomics, + shaderSharedInt64Atomics, + shaderFloat16, + shaderInt8, + descriptorIndexing, + shaderInputAttachmentArrayDynamicIndexing, + shaderUniformTexelBufferArrayDynamicIndexing, + shaderStorageTexelBufferArrayDynamicIndexing, + shaderUniformBufferArrayNonUniformIndexing, + shaderSampledImageArrayNonUniformIndexing, + shaderStorageBufferArrayNonUniformIndexing, + shaderStorageImageArrayNonUniformIndexing, + shaderInputAttachmentArrayNonUniformIndexing, + shaderUniformTexelBufferArrayNonUniformIndexing, + shaderStorageTexelBufferArrayNonUniformIndexing, + descriptorBindingUniformBufferUpdateAfterBind, + descriptorBindingSampledImageUpdateAfterBind, + descriptorBindingStorageImageUpdateAfterBind, + descriptorBindingStorageBufferUpdateAfterBind, + descriptorBindingUniformTexelBufferUpdateAfterBind, + descriptorBindingStorageTexelBufferUpdateAfterBind, + descriptorBindingUpdateUnusedWhilePending, + descriptorBindingPartiallyBound, + descriptorBindingVariableDescriptorCount, + runtimeDescriptorArray, + samplerFilterMinmax, + scalarBlockLayout, + imagelessFramebuffer, + uniformBufferStandardLayout, + shaderSubgroupExtendedTypes, + separateDepthStencilLayouts, + hostQueryReset, + timelineSemaphore, + bufferDeviceAddress, + bufferDeviceAddressCaptureReplay, + bufferDeviceAddressMultiDevice, + vulkanMemoryModel, + vulkanMemoryModelDeviceScope, + vulkanMemoryModelAvailabilityVisibilityChains, + shaderOutputViewportIndex, + shaderOutputLayer, + subgroupBroadcastDynamicId ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVulkan12Features const & ) const = default; #else bool operator==( PhysicalDeviceVulkan12Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( samplerMirrorClampToEdge == rhs.samplerMirrorClampToEdge ) && - ( drawIndirectCount == rhs.drawIndirectCount ) && - ( storageBuffer8BitAccess == rhs.storageBuffer8BitAccess ) && - ( uniformAndStorageBuffer8BitAccess == rhs.uniformAndStorageBuffer8BitAccess ) && - ( storagePushConstant8 == rhs.storagePushConstant8 ) && - ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics ) && - ( shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics ) && ( shaderFloat16 == rhs.shaderFloat16 ) && - ( shaderInt8 == rhs.shaderInt8 ) && ( descriptorIndexing == rhs.descriptorIndexing ) && - ( shaderInputAttachmentArrayDynamicIndexing == rhs.shaderInputAttachmentArrayDynamicIndexing ) && - ( shaderUniformTexelBufferArrayDynamicIndexing == rhs.shaderUniformTexelBufferArrayDynamicIndexing ) && - ( shaderStorageTexelBufferArrayDynamicIndexing == rhs.shaderStorageTexelBufferArrayDynamicIndexing ) && - ( shaderUniformBufferArrayNonUniformIndexing == rhs.shaderUniformBufferArrayNonUniformIndexing ) && - ( shaderSampledImageArrayNonUniformIndexing == rhs.shaderSampledImageArrayNonUniformIndexing ) && - ( shaderStorageBufferArrayNonUniformIndexing == rhs.shaderStorageBufferArrayNonUniformIndexing ) && - ( shaderStorageImageArrayNonUniformIndexing == rhs.shaderStorageImageArrayNonUniformIndexing ) && - ( shaderInputAttachmentArrayNonUniformIndexing == rhs.shaderInputAttachmentArrayNonUniformIndexing ) && - ( shaderUniformTexelBufferArrayNonUniformIndexing == - rhs.shaderUniformTexelBufferArrayNonUniformIndexing ) && - ( shaderStorageTexelBufferArrayNonUniformIndexing == - rhs.shaderStorageTexelBufferArrayNonUniformIndexing ) && - ( descriptorBindingUniformBufferUpdateAfterBind == rhs.descriptorBindingUniformBufferUpdateAfterBind ) && - ( descriptorBindingSampledImageUpdateAfterBind == rhs.descriptorBindingSampledImageUpdateAfterBind ) && - ( descriptorBindingStorageImageUpdateAfterBind == rhs.descriptorBindingStorageImageUpdateAfterBind ) && - ( descriptorBindingStorageBufferUpdateAfterBind == rhs.descriptorBindingStorageBufferUpdateAfterBind ) && - ( descriptorBindingUniformTexelBufferUpdateAfterBind == - rhs.descriptorBindingUniformTexelBufferUpdateAfterBind ) && - ( descriptorBindingStorageTexelBufferUpdateAfterBind == - rhs.descriptorBindingStorageTexelBufferUpdateAfterBind ) && - ( descriptorBindingUpdateUnusedWhilePending == rhs.descriptorBindingUpdateUnusedWhilePending ) && - ( descriptorBindingPartiallyBound == rhs.descriptorBindingPartiallyBound ) && - ( descriptorBindingVariableDescriptorCount == rhs.descriptorBindingVariableDescriptorCount ) && - ( runtimeDescriptorArray == rhs.runtimeDescriptorArray ) && - ( samplerFilterMinmax == rhs.samplerFilterMinmax ) && ( scalarBlockLayout == rhs.scalarBlockLayout ) && - ( imagelessFramebuffer == rhs.imagelessFramebuffer ) && - ( uniformBufferStandardLayout == rhs.uniformBufferStandardLayout ) && - ( shaderSubgroupExtendedTypes == rhs.shaderSubgroupExtendedTypes ) && - ( separateDepthStencilLayouts == rhs.separateDepthStencilLayouts ) && - ( hostQueryReset == rhs.hostQueryReset ) && ( timelineSemaphore == rhs.timelineSemaphore ) && - ( bufferDeviceAddress == rhs.bufferDeviceAddress ) && - ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) && - ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice ) && - ( vulkanMemoryModel == rhs.vulkanMemoryModel ) && - ( vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope ) && - ( vulkanMemoryModelAvailabilityVisibilityChains == rhs.vulkanMemoryModelAvailabilityVisibilityChains ) && - ( shaderOutputViewportIndex == rhs.shaderOutputViewportIndex ) && - ( shaderOutputLayer == rhs.shaderOutputLayer ) && - ( subgroupBroadcastDynamicId == rhs.subgroupBroadcastDynamicId ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVulkan12Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -69882,111 +65594,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceVulkan12Features; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features const & physicalDeviceVulkan12Features ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkan12Features.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkan12Features.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.samplerMirrorClampToEdge ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.drawIndirectCount ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.storageBuffer8BitAccess ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.uniformAndStorageBuffer8BitAccess ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.storagePushConstant8 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderBufferInt64Atomics ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderSharedInt64Atomics ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderFloat16 ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderInt8 ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorIndexing ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderUniformBufferArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderSampledImageArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderStorageBufferArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderStorageImageArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceVulkan12Features.descriptorBindingUniformBufferUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingSampledImageUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingStorageImageUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceVulkan12Features.descriptorBindingStorageBufferUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceVulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceVulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingUpdateUnusedWhilePending ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingPartiallyBound ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.descriptorBindingVariableDescriptorCount ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.runtimeDescriptorArray ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.samplerFilterMinmax ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.scalarBlockLayout ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.imagelessFramebuffer ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.uniformBufferStandardLayout ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderSubgroupExtendedTypes ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.separateDepthStencilLayouts ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.hostQueryReset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.timelineSemaphore ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.bufferDeviceAddress ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.bufferDeviceAddressCaptureReplay ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.bufferDeviceAddressMultiDevice ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.vulkanMemoryModel ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.vulkanMemoryModelDeviceScope ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceVulkan12Features.vulkanMemoryModelAvailabilityVisibilityChains ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderOutputViewportIndex ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.shaderOutputLayer ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Features.subgroupBroadcastDynamicId ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceVulkan12Properties { using NativeType = VkPhysicalDeviceVulkan12Properties; @@ -70121,90 +65728,143 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPhysicalDeviceVulkan12Properties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVulkan12Properties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceVulkan12Properties &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVulkan12Properties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::ConformanceVersion const &, + VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence const &, + VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::ResolveModeFlags const &, + VULKAN_HPP_NAMESPACE::ResolveModeFlags const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + uint64_t const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + driverID, + driverName, + driverInfo, + conformanceVersion, + denormBehaviorIndependence, + roundingModeIndependence, + shaderSignedZeroInfNanPreserveFloat16, + shaderSignedZeroInfNanPreserveFloat32, + shaderSignedZeroInfNanPreserveFloat64, + shaderDenormPreserveFloat16, + shaderDenormPreserveFloat32, + shaderDenormPreserveFloat64, + shaderDenormFlushToZeroFloat16, + shaderDenormFlushToZeroFloat32, + shaderDenormFlushToZeroFloat64, + shaderRoundingModeRTEFloat16, + shaderRoundingModeRTEFloat32, + shaderRoundingModeRTEFloat64, + shaderRoundingModeRTZFloat16, + shaderRoundingModeRTZFloat32, + shaderRoundingModeRTZFloat64, + maxUpdateAfterBindDescriptorsInAllPools, + shaderUniformBufferArrayNonUniformIndexingNative, + shaderSampledImageArrayNonUniformIndexingNative, + shaderStorageBufferArrayNonUniformIndexingNative, + shaderStorageImageArrayNonUniformIndexingNative, + shaderInputAttachmentArrayNonUniformIndexingNative, + robustBufferAccessUpdateAfterBind, + quadDivergentImplicitLod, + maxPerStageDescriptorUpdateAfterBindSamplers, + maxPerStageDescriptorUpdateAfterBindUniformBuffers, + maxPerStageDescriptorUpdateAfterBindStorageBuffers, + maxPerStageDescriptorUpdateAfterBindSampledImages, + maxPerStageDescriptorUpdateAfterBindStorageImages, + maxPerStageDescriptorUpdateAfterBindInputAttachments, + maxPerStageUpdateAfterBindResources, + maxDescriptorSetUpdateAfterBindSamplers, + maxDescriptorSetUpdateAfterBindUniformBuffers, + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, + maxDescriptorSetUpdateAfterBindStorageBuffers, + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, + maxDescriptorSetUpdateAfterBindSampledImages, + maxDescriptorSetUpdateAfterBindStorageImages, + maxDescriptorSetUpdateAfterBindInputAttachments, + supportedDepthResolveModes, + supportedStencilResolveModes, + independentResolveNone, + independentResolve, + filterMinmaxSingleComponentFormats, + filterMinmaxImageComponentMapping, + maxTimelineSemaphoreValueDifference, + framebufferIntegerColorSampleCounts ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVulkan12Properties const & ) const = default; #else bool operator==( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) && - ( driverName == rhs.driverName ) && ( driverInfo == rhs.driverInfo ) && - ( conformanceVersion == rhs.conformanceVersion ) && - ( denormBehaviorIndependence == rhs.denormBehaviorIndependence ) && - ( roundingModeIndependence == rhs.roundingModeIndependence ) && - ( shaderSignedZeroInfNanPreserveFloat16 == rhs.shaderSignedZeroInfNanPreserveFloat16 ) && - ( shaderSignedZeroInfNanPreserveFloat32 == rhs.shaderSignedZeroInfNanPreserveFloat32 ) && - ( shaderSignedZeroInfNanPreserveFloat64 == rhs.shaderSignedZeroInfNanPreserveFloat64 ) && - ( shaderDenormPreserveFloat16 == rhs.shaderDenormPreserveFloat16 ) && - ( shaderDenormPreserveFloat32 == rhs.shaderDenormPreserveFloat32 ) && - ( shaderDenormPreserveFloat64 == rhs.shaderDenormPreserveFloat64 ) && - ( shaderDenormFlushToZeroFloat16 == rhs.shaderDenormFlushToZeroFloat16 ) && - ( shaderDenormFlushToZeroFloat32 == rhs.shaderDenormFlushToZeroFloat32 ) && - ( shaderDenormFlushToZeroFloat64 == rhs.shaderDenormFlushToZeroFloat64 ) && - ( shaderRoundingModeRTEFloat16 == rhs.shaderRoundingModeRTEFloat16 ) && - ( shaderRoundingModeRTEFloat32 == rhs.shaderRoundingModeRTEFloat32 ) && - ( shaderRoundingModeRTEFloat64 == rhs.shaderRoundingModeRTEFloat64 ) && - ( shaderRoundingModeRTZFloat16 == rhs.shaderRoundingModeRTZFloat16 ) && - ( shaderRoundingModeRTZFloat32 == rhs.shaderRoundingModeRTZFloat32 ) && - ( shaderRoundingModeRTZFloat64 == rhs.shaderRoundingModeRTZFloat64 ) && - ( maxUpdateAfterBindDescriptorsInAllPools == rhs.maxUpdateAfterBindDescriptorsInAllPools ) && - ( shaderUniformBufferArrayNonUniformIndexingNative == - rhs.shaderUniformBufferArrayNonUniformIndexingNative ) && - ( shaderSampledImageArrayNonUniformIndexingNative == - rhs.shaderSampledImageArrayNonUniformIndexingNative ) && - ( shaderStorageBufferArrayNonUniformIndexingNative == - rhs.shaderStorageBufferArrayNonUniformIndexingNative ) && - ( shaderStorageImageArrayNonUniformIndexingNative == - rhs.shaderStorageImageArrayNonUniformIndexingNative ) && - ( shaderInputAttachmentArrayNonUniformIndexingNative == - rhs.shaderInputAttachmentArrayNonUniformIndexingNative ) && - ( robustBufferAccessUpdateAfterBind == rhs.robustBufferAccessUpdateAfterBind ) && - ( quadDivergentImplicitLod == rhs.quadDivergentImplicitLod ) && - ( maxPerStageDescriptorUpdateAfterBindSamplers == rhs.maxPerStageDescriptorUpdateAfterBindSamplers ) && - ( maxPerStageDescriptorUpdateAfterBindUniformBuffers == - rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers ) && - ( maxPerStageDescriptorUpdateAfterBindStorageBuffers == - rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers ) && - ( maxPerStageDescriptorUpdateAfterBindSampledImages == - rhs.maxPerStageDescriptorUpdateAfterBindSampledImages ) && - ( maxPerStageDescriptorUpdateAfterBindStorageImages == - rhs.maxPerStageDescriptorUpdateAfterBindStorageImages ) && - ( maxPerStageDescriptorUpdateAfterBindInputAttachments == - rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments ) && - ( maxPerStageUpdateAfterBindResources == rhs.maxPerStageUpdateAfterBindResources ) && - ( maxDescriptorSetUpdateAfterBindSamplers == rhs.maxDescriptorSetUpdateAfterBindSamplers ) && - ( maxDescriptorSetUpdateAfterBindUniformBuffers == rhs.maxDescriptorSetUpdateAfterBindUniformBuffers ) && - ( maxDescriptorSetUpdateAfterBindUniformBuffersDynamic == - rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ) && - ( maxDescriptorSetUpdateAfterBindStorageBuffers == rhs.maxDescriptorSetUpdateAfterBindStorageBuffers ) && - ( maxDescriptorSetUpdateAfterBindStorageBuffersDynamic == - rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ) && - ( maxDescriptorSetUpdateAfterBindSampledImages == rhs.maxDescriptorSetUpdateAfterBindSampledImages ) && - ( maxDescriptorSetUpdateAfterBindStorageImages == rhs.maxDescriptorSetUpdateAfterBindStorageImages ) && - ( maxDescriptorSetUpdateAfterBindInputAttachments == - rhs.maxDescriptorSetUpdateAfterBindInputAttachments ) && - ( supportedDepthResolveModes == rhs.supportedDepthResolveModes ) && - ( supportedStencilResolveModes == rhs.supportedStencilResolveModes ) && - ( independentResolveNone == rhs.independentResolveNone ) && - ( independentResolve == rhs.independentResolve ) && - ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) && - ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping ) && - ( maxTimelineSemaphoreValueDifference == rhs.maxTimelineSemaphoreValueDifference ) && - ( framebufferIntegerColorSampleCounts == rhs.framebufferIntegerColorSampleCounts ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -70281,134 +65941,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceVulkan12Properties; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties const & physicalDeviceVulkan12Properties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkan12Properties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkan12Properties.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DriverId, seed, physicalDeviceVulkan12Properties.driverID ); - for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceVulkan12Properties.driverName[i] ); - } - for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, physicalDeviceVulkan12Properties.driverInfo[i] ); - } - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ConformanceVersion, seed, physicalDeviceVulkan12Properties.conformanceVersion ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence, - seed, - physicalDeviceVulkan12Properties.denormBehaviorIndependence ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence, - seed, - physicalDeviceVulkan12Properties.roundingModeIndependence ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat16 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat32 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat64 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat16 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat32 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat64 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat16 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat32 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat64 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat16 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat32 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat64 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat16 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat32 ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat64 ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan12Properties.maxUpdateAfterBindDescriptorsInAllPools ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceVulkan12Properties.shaderUniformBufferArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceVulkan12Properties.shaderSampledImageArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceVulkan12Properties.shaderStorageBufferArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceVulkan12Properties.shaderStorageImageArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceVulkan12Properties.shaderInputAttachmentArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.robustBufferAccessUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.quadDivergentImplicitLod ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan12Properties.maxPerStageUpdateAfterBindResources ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ResolveModeFlags, seed, physicalDeviceVulkan12Properties.supportedDepthResolveModes ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ResolveModeFlags, seed, physicalDeviceVulkan12Properties.supportedStencilResolveModes ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.independentResolveNone ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.independentResolve ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.filterMinmaxSingleComponentFormats ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkan12Properties.filterMinmaxImageComponentMapping ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, physicalDeviceVulkan12Properties.maxTimelineSemaphoreValueDifference ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleCountFlags, - seed, - physicalDeviceVulkan12Properties.framebufferIntegerColorSampleCounts ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceVulkanMemoryModelFeatures { using NativeType = VkPhysicalDeviceVulkanMemoryModelFeatures; @@ -70475,29 +66007,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceVulkanMemoryModelFeatures const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVulkanMemoryModelFeatures const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceVulkanMemoryModelFeatures &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceVulkanMemoryModelFeatures &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, vulkanMemoryModel, vulkanMemoryModelDeviceScope, vulkanMemoryModelAvailabilityVisibilityChains ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVulkanMemoryModelFeatures const & ) const = default; #else bool operator==( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vulkanMemoryModel == rhs.vulkanMemoryModel ) && - ( vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope ) && - ( vulkanMemoryModelAvailabilityVisibilityChains == rhs.vulkanMemoryModelAvailabilityVisibilityChains ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -70525,30 +66070,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures const & - physicalDeviceVulkanMemoryModelFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceVulkanMemoryModelFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceVulkanMemoryModelFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModel ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelDeviceScope ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelAvailabilityVisibilityChains ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { using NativeType = VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; @@ -70630,31 +66151,47 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + workgroupMemoryExplicitLayout, + workgroupMemoryExplicitLayoutScalarBlockLayout, + workgroupMemoryExplicitLayout8BitAccess, + workgroupMemoryExplicitLayout16BitAccess ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( workgroupMemoryExplicitLayout == rhs.workgroupMemoryExplicitLayout ) && - ( workgroupMemoryExplicitLayoutScalarBlockLayout == rhs.workgroupMemoryExplicitLayoutScalarBlockLayout ) && - ( workgroupMemoryExplicitLayout8BitAccess == rhs.workgroupMemoryExplicitLayout8BitAccess ) && - ( workgroupMemoryExplicitLayout16BitAccess == rhs.workgroupMemoryExplicitLayout16BitAccess ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -70683,39 +66220,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & - physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayoutScalarBlockLayout ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout8BitAccess ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout16BitAccess ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { using NativeType = VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; @@ -70766,27 +66270,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, ycbcr2plane444Formats ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcr2plane444Formats == rhs.ycbcr2plane444Formats ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -70811,26 +66325,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & - physicalDeviceYcbcr2Plane444FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.ycbcr2plane444Formats ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceYcbcrImageArraysFeaturesEXT { using NativeType = VkPhysicalDeviceYcbcrImageArraysFeaturesEXT; @@ -70879,27 +66373,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, ycbcrImageArrays ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcrImageArrays == rhs.ycbcrImageArrays ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -70924,26 +66428,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceYcbcrImageArraysFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT const & - physicalDeviceYcbcrImageArraysFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceYcbcrImageArraysFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceYcbcrImageArraysFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, physicalDeviceYcbcrImageArraysFeaturesEXT.ycbcrImageArrays ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR { using NativeType = VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR; @@ -70996,28 +66480,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderZeroInitializeWorkgroupMemory ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderZeroInitializeWorkgroupMemory == rhs.shaderZeroInitializeWorkgroupMemory ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -71043,28 +66536,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & - physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, - seed, - physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.shaderZeroInitializeWorkgroupMemory ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineCacheCreateInfo { using NativeType = VkPipelineCacheCreateInfo; @@ -71142,28 +66613,41 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineCacheCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineCacheCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineCacheCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineCacheCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, initialDataSize, pInitialData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCacheCreateInfo const & ) const = default; #else bool operator==( PipelineCacheCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( initialDataSize == rhs.initialDataSize ) && ( pInitialData == rhs.pInitialData ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineCacheCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -71188,26 +66672,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineCacheCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & pipelineCacheCreateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCacheCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCacheCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags, seed, pipelineCacheCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( size_t, seed, pipelineCacheCreateInfo.initialDataSize ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCacheCreateInfo.pInitialData ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineCacheHeaderVersionOne { using NativeType = VkPipelineCacheHeaderVersionOne; @@ -71278,29 +66742,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineCacheHeaderVersionOne const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineCacheHeaderVersionOne const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineCacheHeaderVersionOne &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineCacheHeaderVersionOne &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( headerSize, headerVersion, vendorID, deviceID, pipelineCacheUUID ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCacheHeaderVersionOne const & ) const = default; #else bool operator==( PipelineCacheHeaderVersionOne const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( headerSize == rhs.headerSize ) && ( headerVersion == rhs.headerVersion ) && - ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) && - ( pipelineCacheUUID == rhs.pipelineCacheUUID ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineCacheHeaderVersionOne const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -71321,30 +66797,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "PipelineCacheHeaderVersionOne is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne const & pipelineCacheHeaderVersionOne ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCacheHeaderVersionOne.headerSize ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersion, seed, pipelineCacheHeaderVersionOne.headerVersion ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCacheHeaderVersionOne.vendorID ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCacheHeaderVersionOne.deviceID ); - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, pipelineCacheHeaderVersionOne.pipelineCacheUUID[i] ); - } - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineColorBlendAdvancedStateCreateInfoEXT { using NativeType = VkPipelineColorBlendAdvancedStateCreateInfoEXT; @@ -71414,28 +66866,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineColorBlendAdvancedStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineColorBlendAdvancedStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineColorBlendAdvancedStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineColorBlendAdvancedStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcPremultiplied, dstPremultiplied, blendOverlap ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineColorBlendAdvancedStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcPremultiplied == rhs.srcPremultiplied ) && - ( dstPremultiplied == rhs.dstPremultiplied ) && ( blendOverlap == rhs.blendOverlap ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -71462,30 +66927,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineColorBlendAdvancedStateCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT const & - pipelineColorBlendAdvancedStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.srcPremultiplied ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.dstPremultiplied ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::BlendOverlapEXT, seed, pipelineColorBlendAdvancedStateCreateInfoEXT.blendOverlap ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineColorWriteCreateInfoEXT { using NativeType = VkPipelineColorWriteCreateInfoEXT; @@ -71559,28 +67000,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineColorWriteCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineColorWriteCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineColorWriteCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineColorWriteCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, attachmentCount, pColorWriteEnables ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineColorWriteCreateInfoEXT const & ) const = default; #else bool operator==( PipelineColorWriteCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentCount == rhs.attachmentCount ) && - ( pColorWriteEnables == rhs.pColorWriteEnables ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineColorWriteCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -71605,27 +67058,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineColorWriteCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT const & pipelineColorWriteCreateInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineColorWriteCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineColorWriteCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineColorWriteCreateInfoEXT.attachmentCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::Bool32 *, seed, pipelineColorWriteCreateInfoEXT.pColorWriteEnables ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineCompilerControlCreateInfoAMD { using NativeType = VkPipelineCompilerControlCreateInfoAMD; @@ -71673,27 +67105,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineCompilerControlCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineCompilerControlCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineCompilerControlCreateInfoAMD &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineCompilerControlCreateInfoAMD &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, compilerControlFlags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCompilerControlCreateInfoAMD const & ) const = default; #else bool operator==( PipelineCompilerControlCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compilerControlFlags == rhs.compilerControlFlags ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineCompilerControlCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -71717,26 +67161,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineCompilerControlCreateInfoAMD; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD const & - pipelineCompilerControlCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCompilerControlCreateInfoAMD.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCompilerControlCreateInfoAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagsAMD, - seed, - pipelineCompilerControlCreateInfoAMD.compilerControlFlags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineCoverageModulationStateCreateInfoNV { using NativeType = VkPipelineCoverageModulationStateCreateInfoNV; @@ -71848,31 +67272,49 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineCoverageModulationStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineCoverageModulationStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineCoverageModulationStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineCoverageModulationStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + coverageModulationMode, + coverageModulationTableEnable, + coverageModulationTableCount, + pCoverageModulationTable ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCoverageModulationStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineCoverageModulationStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( coverageModulationMode == rhs.coverageModulationMode ) && - ( coverageModulationTableEnable == rhs.coverageModulationTableEnable ) && - ( coverageModulationTableCount == rhs.coverageModulationTableCount ) && - ( pCoverageModulationTable == rhs.pCoverageModulationTable ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineCoverageModulationStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -71902,35 +67344,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineCoverageModulationStateCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV const & - pipelineCoverageModulationStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCoverageModulationStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCoverageModulationStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateFlagsNV, - seed, - pipelineCoverageModulationStateCreateInfoNV.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV, - seed, - pipelineCoverageModulationStateCreateInfoNV.coverageModulationMode ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableEnable ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableCount ); - VULKAN_HPP_HASH_COMBINE( - const float *, seed, pipelineCoverageModulationStateCreateInfoNV.pCoverageModulationTable ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineCoverageReductionStateCreateInfoNV { using NativeType = VkPipelineCoverageReductionStateCreateInfoNV; @@ -71991,28 +67404,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineCoverageReductionStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineCoverageReductionStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineCoverageReductionStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineCoverageReductionStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, coverageReductionMode ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCoverageReductionStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineCoverageReductionStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( coverageReductionMode == rhs.coverageReductionMode ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineCoverageReductionStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -72039,30 +67464,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineCoverageReductionStateCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV const & - pipelineCoverageReductionStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCoverageReductionStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCoverageReductionStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateFlagsNV, - seed, - pipelineCoverageReductionStateCreateInfoNV.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV, - seed, - pipelineCoverageReductionStateCreateInfoNV.coverageReductionMode ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineCoverageToColorStateCreateInfoNV { using NativeType = VkPipelineCoverageToColorStateCreateInfoNV; @@ -72131,29 +67532,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineCoverageToColorStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineCoverageToColorStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineCoverageToColorStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineCoverageToColorStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, coverageToColorEnable, coverageToColorLocation ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCoverageToColorStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineCoverageToColorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( coverageToColorEnable == rhs.coverageToColorEnable ) && - ( coverageToColorLocation == rhs.coverageToColorLocation ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineCoverageToColorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -72180,30 +67593,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineCoverageToColorStateCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV const & - pipelineCoverageToColorStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCoverageToColorStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCoverageToColorStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateFlagsNV, - seed, - pipelineCoverageToColorStateCreateInfoNV.flags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorEnable ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorLocation ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineCreationFeedbackEXT { using NativeType = VkPipelineCreationFeedbackEXT; @@ -72232,27 +67621,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPipelineCreationFeedbackEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineCreationFeedbackEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineCreationFeedbackEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineCreationFeedbackEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( flags, duration ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCreationFeedbackEXT const & ) const = default; #else bool operator==( PipelineCreationFeedbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && ( duration == rhs.duration ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineCreationFeedbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -72269,24 +67668,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "PipelineCreationFeedbackEXT is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT const & pipelineCreationFeedbackEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagsEXT, seed, pipelineCreationFeedbackEXT.flags ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, pipelineCreationFeedbackEXT.duration ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineCreationFeedbackCreateInfoEXT { using NativeType = VkPipelineCreationFeedbackCreateInfoEXT; @@ -72375,30 +67756,42 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineCreationFeedbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineCreationFeedbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineCreationFeedbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineCreationFeedbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, pPipelineCreationFeedback, pipelineStageCreationFeedbackCount, pPipelineStageCreationFeedbacks ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCreationFeedbackCreateInfoEXT const & ) const = default; #else bool operator==( PipelineCreationFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( pPipelineCreationFeedback == rhs.pPipelineCreationFeedback ) && - ( pipelineStageCreationFeedbackCount == rhs.pipelineStageCreationFeedbackCount ) && - ( pPipelineStageCreationFeedbacks == rhs.pPipelineStageCreationFeedbacks ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineCreationFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -72424,30 +67817,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineCreationFeedbackCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfoEXT const & - pipelineCreationFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineCreationFeedbackCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineCreationFeedbackCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT *, - seed, - pipelineCreationFeedbackCreateInfoEXT.pPipelineCreationFeedback ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineCreationFeedbackCreateInfoEXT.pipelineStageCreationFeedbackCount ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT *, - seed, - pipelineCreationFeedbackCreateInfoEXT.pPipelineStageCreationFeedbacks ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineDiscardRectangleStateCreateInfoEXT { using NativeType = VkPipelineDiscardRectangleStateCreateInfoEXT; @@ -72549,29 +67918,42 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineDiscardRectangleStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineDiscardRectangleStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineDiscardRectangleStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineDiscardRectangleStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, discardRectangleMode, discardRectangleCount, pDiscardRectangles ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineDiscardRectangleStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( discardRectangleMode == rhs.discardRectangleMode ) && - ( discardRectangleCount == rhs.discardRectangleCount ) && ( pDiscardRectangles == rhs.pDiscardRectangles ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -72600,33 +67982,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineDiscardRectangleStateCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT const & - pipelineDiscardRectangleStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineDiscardRectangleStateCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineDiscardRectangleStateCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateFlagsEXT, - seed, - pipelineDiscardRectangleStateCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT, - seed, - pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleMode ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::Rect2D *, seed, pipelineDiscardRectangleStateCreateInfoEXT.pDiscardRectangles ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineExecutableInfoKHR { using NativeType = VkPipelineExecutableInfoKHR; @@ -72679,28 +68034,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineExecutableInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineExecutableInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineExecutableInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineExecutableInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipeline, executableIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineExecutableInfoKHR const & ) const = default; #else bool operator==( PipelineExecutableInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline ) && - ( executableIndex == rhs.executableIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineExecutableInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -72724,25 +68091,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineExecutableInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR const & pipelineExecutableInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineExecutableInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineExecutableInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, pipelineExecutableInfoKHR.pipeline ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineExecutableInfoKHR.executableIndex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineExecutableInternalRepresentationKHR { using NativeType = VkPipelineExecutableInternalRepresentationKHR; @@ -72799,29 +68147,43 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPipelineExecutableInternalRepresentationKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineExecutableInternalRepresentationKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineExecutableInternalRepresentationKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineExecutableInternalRepresentationKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + size_t const &, + void * const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, name, description, isText, dataSize, pData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineExecutableInternalRepresentationKHR const & ) const = default; #else bool operator==( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( name == rhs.name ) && - ( description == rhs.description ) && ( isText == rhs.isText ) && ( dataSize == rhs.dataSize ) && - ( pData == rhs.pData ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -72850,35 +68212,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineExecutableInternalRepresentationKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR const & - pipelineExecutableInternalRepresentationKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineExecutableInternalRepresentationKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, pipelineExecutableInternalRepresentationKHR.pNext ); - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, pipelineExecutableInternalRepresentationKHR.name[i] ); - } - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, pipelineExecutableInternalRepresentationKHR.description[i] ); - } - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineExecutableInternalRepresentationKHR.isText ); - VULKAN_HPP_HASH_COMBINE( size_t, seed, pipelineExecutableInternalRepresentationKHR.dataSize ); - VULKAN_HPP_HASH_COMBINE( void *, seed, pipelineExecutableInternalRepresentationKHR.pData ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineExecutablePropertiesKHR { using NativeType = VkPipelineExecutablePropertiesKHR; @@ -72915,28 +68248,42 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPipelineExecutablePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineExecutablePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineExecutablePropertiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineExecutablePropertiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + uint32_t const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stages, name, description, subgroupSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineExecutablePropertiesKHR const & ) const = default; #else bool operator==( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stages == rhs.stages ) && ( name == rhs.name ) && - ( description == rhs.description ) && ( subgroupSize == rhs.subgroupSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -72963,34 +68310,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineExecutablePropertiesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR const & pipelineExecutablePropertiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineExecutablePropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, pipelineExecutablePropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, pipelineExecutablePropertiesKHR.stages ); - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, pipelineExecutablePropertiesKHR.name[i] ); - } - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( char, seed, pipelineExecutablePropertiesKHR.description[i] ); - } - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineExecutablePropertiesKHR.subgroupSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ union PipelineExecutableStatisticValueKHR { using NativeType = VkPipelineExecutableStatisticValueKHR; @@ -73093,16 +68412,31 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPipelineExecutableStatisticKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineExecutableStatisticKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineExecutableStatisticKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineExecutableStatisticKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR const &, + VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, name, description, format, value ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutableStatisticKHR; void * pNext = {}; @@ -73199,28 +68533,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shadingRateType, shadingRate, combinerOps ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineFragmentShadingRateEnumStateCreateInfoNV const & ) const = default; #else - bool operator==( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateType == rhs.shadingRateType ) && - ( shadingRate == rhs.shadingRate ) && ( combinerOps == rhs.combinerOps ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -73249,35 +68596,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineFragmentShadingRateEnumStateCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV const & - pipelineFragmentShadingRateEnumStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FragmentShadingRateTypeNV, - seed, - pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRateType ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::FragmentShadingRateNV, seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRate ); - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR, - seed, - pipelineFragmentShadingRateEnumStateCreateInfoNV.combinerOps[i] ); - } - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineFragmentShadingRateStateCreateInfoKHR { using NativeType = VkPipelineFragmentShadingRateStateCreateInfoKHR; @@ -73339,28 +68657,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineFragmentShadingRateStateCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineFragmentShadingRateStateCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineFragmentShadingRateStateCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineFragmentShadingRateStateCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentSize, combinerOps ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineFragmentShadingRateStateCreateInfoKHR const & ) const = default; #else bool operator==( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentSize == rhs.fragmentSize ) && - ( combinerOps == rhs.combinerOps ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -73386,32 +68716,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineFragmentShadingRateStateCreateInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR const & - pipelineFragmentShadingRateStateCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineFragmentShadingRateStateCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineFragmentShadingRateStateCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Extent2D, seed, pipelineFragmentShadingRateStateCreateInfoKHR.fragmentSize ); - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR, - seed, - pipelineFragmentShadingRateStateCreateInfoKHR.combinerOps[i] ); - } - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineInfoKHR { using NativeType = VkPipelineInfoKHR; @@ -73454,27 +68758,38 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std:: + tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipeline ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineInfoKHR const & ) const = default; #else bool operator==( PipelineInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -73496,23 +68811,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInfoKHR const & pipelineInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, pipelineInfoKHR.pipeline ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PushConstantRange { using NativeType = VkPushConstantRange; @@ -73562,27 +68860,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPushConstantRange const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPushConstantRange const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPushConstantRange &() VULKAN_HPP_NOEXCEPT + explicit operator VkPushConstantRange &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( stageFlags, offset, size ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PushConstantRange const & ) const = default; #else bool operator==( PushConstantRange const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( stageFlags == rhs.stageFlags ) && ( offset == rhs.offset ) && ( size == rhs.size ); + return this->reflect() == rhs.reflect(); } bool operator!=( PushConstantRange const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -73598,23 +68906,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "PushConstantRange is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantRange const & pushConstantRange ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, pushConstantRange.stageFlags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pushConstantRange.offset ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pushConstantRange.size ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineLayoutCreateInfo { using NativeType = VkPipelineLayoutCreateInfo; @@ -73730,30 +69021,43 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineLayoutCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineLayoutCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, setLayoutCount, pSetLayouts, pushConstantRangeCount, pPushConstantRanges ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineLayoutCreateInfo const & ) const = default; #else bool operator==( PipelineLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( setLayoutCount == rhs.setLayoutCount ) && ( pSetLayouts == rhs.pSetLayouts ) && - ( pushConstantRangeCount == rhs.pushConstantRangeCount ) && - ( pPushConstantRanges == rhs.pPushConstantRanges ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -73780,30 +69084,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineLayoutCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & pipelineLayoutCreateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineLayoutCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineLayoutCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags, seed, pipelineLayoutCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineLayoutCreateInfo.setLayoutCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::DescriptorSetLayout *, seed, pipelineLayoutCreateInfo.pSetLayouts ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineLayoutCreateInfo.pushConstantRangeCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::PushConstantRange *, seed, pipelineLayoutCreateInfo.pPushConstantRanges ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineLibraryCreateInfoKHR { using NativeType = VkPipelineLibraryCreateInfoKHR; @@ -73874,28 +69154,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineLibraryCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineLibraryCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineLibraryCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineLibraryCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, libraryCount, pLibraries ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineLibraryCreateInfoKHR const & ) const = default; #else bool operator==( PipelineLibraryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( libraryCount == rhs.libraryCount ) && - ( pLibraries == rhs.pLibraries ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineLibraryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -73920,25 +69212,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineLibraryCreateInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR const & pipelineLibraryCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineLibraryCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineLibraryCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineLibraryCreateInfoKHR.libraryCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Pipeline *, seed, pipelineLibraryCreateInfoKHR.pLibraries ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineRasterizationConservativeStateCreateInfoEXT { using NativeType = VkPipelineRasterizationConservativeStateCreateInfoEXT; @@ -74009,29 +69282,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineRasterizationConservativeStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineRasterizationConservativeStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineRasterizationConservativeStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineRasterizationConservativeStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, conservativeRasterizationMode, extraPrimitiveOverestimationSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationConservativeStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( conservativeRasterizationMode == rhs.conservativeRasterizationMode ) && - ( extraPrimitiveOverestimationSize == rhs.extraPrimitiveOverestimationSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -74059,32 +69344,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineRasterizationConservativeStateCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT const & - pipelineRasterizationConservativeStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationConservativeStateCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationConservativeStateCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateFlagsEXT, - seed, - pipelineRasterizationConservativeStateCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT, - seed, - pipelineRasterizationConservativeStateCreateInfoEXT.conservativeRasterizationMode ); - VULKAN_HPP_HASH_COMBINE( - float, seed, pipelineRasterizationConservativeStateCreateInfoEXT.extraPrimitiveOverestimationSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineRasterizationDepthClipStateCreateInfoEXT { using NativeType = VkPipelineRasterizationDepthClipStateCreateInfoEXT; @@ -74144,28 +69403,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineRasterizationDepthClipStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineRasterizationDepthClipStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineRasterizationDepthClipStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineRasterizationDepthClipStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, depthClipEnable ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationDepthClipStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( depthClipEnable == rhs.depthClipEnable ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -74191,29 +69462,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineRasterizationDepthClipStateCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT const & - pipelineRasterizationDepthClipStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationDepthClipStateCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationDepthClipStateCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateFlagsEXT, - seed, - pipelineRasterizationDepthClipStateCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationDepthClipStateCreateInfoEXT.depthClipEnable ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineRasterizationLineStateCreateInfoEXT { using NativeType = VkPipelineRasterizationLineStateCreateInfoEXT; @@ -74292,30 +69540,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineRasterizationLineStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineRasterizationLineStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineRasterizationLineStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineRasterizationLineStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, lineRasterizationMode, stippledLineEnable, lineStippleFactor, lineStipplePattern ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationLineStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( lineRasterizationMode == rhs.lineRasterizationMode ) && - ( stippledLineEnable == rhs.stippledLineEnable ) && ( lineStippleFactor == rhs.lineStippleFactor ) && - ( lineStipplePattern == rhs.lineStipplePattern ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -74344,31 +69604,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineRasterizationLineStateCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT const & - pipelineRasterizationLineStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationLineStateCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationLineStateCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT, - seed, - pipelineRasterizationLineStateCreateInfoEXT.lineRasterizationMode ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineRasterizationLineStateCreateInfoEXT.stippledLineEnable ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineRasterizationLineStateCreateInfoEXT.lineStippleFactor ); - VULKAN_HPP_HASH_COMBINE( uint16_t, seed, pipelineRasterizationLineStateCreateInfoEXT.lineStipplePattern ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineRasterizationProvokingVertexStateCreateInfoEXT { using NativeType = VkPipelineRasterizationProvokingVertexStateCreateInfoEXT; @@ -74421,27 +69656,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, provokingVertexMode ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexMode == rhs.provokingVertexMode ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -74468,27 +69715,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineRasterizationProvokingVertexStateCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT const & - pipelineRasterizationProvokingVertexStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT, - seed, - pipelineRasterizationProvokingVertexStateCreateInfoEXT.provokingVertexMode ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineRasterizationStateRasterizationOrderAMD { using NativeType = VkPipelineRasterizationStateRasterizationOrderAMD; @@ -74540,27 +69766,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineRasterizationStateRasterizationOrderAMD const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineRasterizationStateRasterizationOrderAMD const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineRasterizationStateRasterizationOrderAMD &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineRasterizationStateRasterizationOrderAMD &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rasterizationOrder ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationStateRasterizationOrderAMD const & ) const = default; #else bool operator==( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rasterizationOrder == rhs.rasterizationOrder ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -74586,27 +69824,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineRasterizationStateRasterizationOrderAMD; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD const & - pipelineRasterizationStateRasterizationOrderAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationStateRasterizationOrderAMD.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationStateRasterizationOrderAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RasterizationOrderAMD, - seed, - pipelineRasterizationStateRasterizationOrderAMD.rasterizationOrder ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineRasterizationStateStreamCreateInfoEXT { using NativeType = VkPipelineRasterizationStateStreamCreateInfoEXT; @@ -74666,28 +69883,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineRasterizationStateStreamCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineRasterizationStateStreamCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineRasterizationStateStreamCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineRasterizationStateStreamCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, rasterizationStream ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationStateStreamCreateInfoEXT const & ) const = default; #else bool operator==( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( rasterizationStream == rhs.rasterizationStream ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -74713,28 +69942,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineRasterizationStateStreamCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT const & - pipelineRasterizationStateStreamCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRasterizationStateStreamCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRasterizationStateStreamCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateFlagsEXT, - seed, - pipelineRasterizationStateStreamCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineRasterizationStateStreamCreateInfoEXT.rasterizationStream ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineRenderingCreateInfoKHR { using NativeType = VkPipelineRenderingCreateInfoKHR; @@ -74841,31 +70048,49 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineRenderingCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineRenderingCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineRenderingCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineRenderingCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + viewMask, + colorAttachmentCount, + pColorAttachmentFormats, + depthAttachmentFormat, + stencilAttachmentFormat ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRenderingCreateInfoKHR const & ) const = default; #else bool operator==( PipelineRenderingCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewMask == rhs.viewMask ) && - ( colorAttachmentCount == rhs.colorAttachmentCount ) && - ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) && - ( depthAttachmentFormat == rhs.depthAttachmentFormat ) && - ( stencilAttachmentFormat == rhs.stencilAttachmentFormat ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineRenderingCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -74893,30 +70118,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineRenderingCreateInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfoKHR const & pipelineRenderingCreateInfoKHR ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRenderingCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRenderingCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineRenderingCreateInfoKHR.viewMask ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineRenderingCreateInfoKHR.colorAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::Format *, seed, pipelineRenderingCreateInfoKHR.pColorAttachmentFormats ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, pipelineRenderingCreateInfoKHR.depthAttachmentFormat ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Format, seed, pipelineRenderingCreateInfoKHR.stencilAttachmentFormat ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineRepresentativeFragmentTestStateCreateInfoNV { using NativeType = VkPipelineRepresentativeFragmentTestStateCreateInfoNV; @@ -74968,28 +70169,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, representativeFragmentTestEnable ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRepresentativeFragmentTestStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( representativeFragmentTestEnable == rhs.representativeFragmentTestEnable ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -75014,27 +70224,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineRepresentativeFragmentTestStateCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV const & - pipelineRepresentativeFragmentTestStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, - seed, - pipelineRepresentativeFragmentTestStateCreateInfoNV.representativeFragmentTestEnable ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineSampleLocationsStateCreateInfoEXT { using NativeType = VkPipelineSampleLocationsStateCreateInfoEXT; @@ -75094,29 +70283,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineSampleLocationsStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineSampleLocationsStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineSampleLocationsStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineSampleLocationsStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, sampleLocationsEnable, sampleLocationsInfo ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineSampleLocationsStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( sampleLocationsEnable == rhs.sampleLocationsEnable ) && - ( sampleLocationsInfo == rhs.sampleLocationsInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -75142,29 +70342,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineSampleLocationsStateCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT const & - pipelineSampleLocationsStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineSampleLocationsStateCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineSampleLocationsStateCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsEnable ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT, - seed, - pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsInfo ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT { using NativeType = VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; @@ -75200,27 +70377,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, requiredSubgroupSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & ) const = default; #else bool operator==( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( requiredSubgroupSize == rhs.requiredSubgroupSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -75245,26 +70432,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & - pipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineShaderStageRequiredSubgroupSizeCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, pipelineShaderStageRequiredSubgroupSizeCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, pipelineShaderStageRequiredSubgroupSizeCreateInfoEXT.requiredSubgroupSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineTessellationDomainOriginStateCreateInfo { using NativeType = VkPipelineTessellationDomainOriginStateCreateInfo; @@ -75315,27 +70482,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineTessellationDomainOriginStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineTessellationDomainOriginStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineTessellationDomainOriginStateCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineTessellationDomainOriginStateCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, domainOrigin ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineTessellationDomainOriginStateCreateInfo const & ) const = default; #else bool operator==( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( domainOrigin == rhs.domainOrigin ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -75362,27 +70541,6 @@ namespace VULKAN_HPP_NAMESPACE }; using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo const & - pipelineTessellationDomainOriginStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineTessellationDomainOriginStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineTessellationDomainOriginStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin, - seed, - pipelineTessellationDomainOriginStateCreateInfo.domainOrigin ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct VertexInputBindingDivisorDescriptionEXT { using NativeType = VkVertexInputBindingDivisorDescriptionEXT; @@ -75429,27 +70587,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVertexInputBindingDivisorDescriptionEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVertexInputBindingDivisorDescriptionEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVertexInputBindingDivisorDescriptionEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVertexInputBindingDivisorDescriptionEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( binding, divisor ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VertexInputBindingDivisorDescriptionEXT const & ) const = default; #else bool operator==( VertexInputBindingDivisorDescriptionEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( binding == rhs.binding ) && ( divisor == rhs.divisor ); + return this->reflect() == rhs.reflect(); } bool operator!=( VertexInputBindingDivisorDescriptionEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -75467,23 +70635,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "VertexInputBindingDivisorDescriptionEXT is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT const & - vertexInputBindingDivisorDescriptionEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDivisorDescriptionEXT.binding ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDivisorDescriptionEXT.divisor ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineVertexInputDivisorStateCreateInfoEXT { using NativeType = VkPipelineVertexInputDivisorStateCreateInfoEXT; @@ -75566,29 +70717,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineVertexInputDivisorStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineVertexInputDivisorStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineVertexInputDivisorStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineVertexInputDivisorStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vertexBindingDivisorCount, pVertexBindingDivisors ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineVertexInputDivisorStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( vertexBindingDivisorCount == rhs.vertexBindingDivisorCount ) && - ( pVertexBindingDivisors == rhs.pVertexBindingDivisors ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -75614,28 +70776,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineVertexInputDivisorStateCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT const & - pipelineVertexInputDivisorStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineVertexInputDivisorStateCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineVertexInputDivisorStateCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineVertexInputDivisorStateCreateInfoEXT.vertexBindingDivisorCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT *, - seed, - pipelineVertexInputDivisorStateCreateInfoEXT.pVertexBindingDivisors ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineViewportCoarseSampleOrderStateCreateInfoNV { using NativeType = VkPipelineViewportCoarseSampleOrderStateCreateInfoNV; @@ -75728,29 +70868,41 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, sampleOrderType, customSampleOrderCount, pCustomSampleOrders ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleOrderType == rhs.sampleOrderType ) && - ( customSampleOrderCount == rhs.customSampleOrderCount ) && - ( pCustomSampleOrders == rhs.pCustomSampleOrders ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -75778,32 +70930,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineViewportCoarseSampleOrderStateCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV const & - pipelineViewportCoarseSampleOrderStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV, - seed, - pipelineViewportCoarseSampleOrderStateCreateInfoNV.sampleOrderType ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.customSampleOrderCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV *, - seed, - pipelineViewportCoarseSampleOrderStateCreateInfoNV.pCustomSampleOrders ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineViewportDepthClipControlCreateInfoEXT { using NativeType = VkPipelineViewportDepthClipControlCreateInfoEXT; @@ -75853,27 +70979,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineViewportDepthClipControlCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineViewportDepthClipControlCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineViewportDepthClipControlCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineViewportDepthClipControlCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, negativeOneToOne ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportDepthClipControlCreateInfoEXT const & ) const = default; #else bool operator==( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( negativeOneToOne == rhs.negativeOneToOne ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -75898,26 +71034,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineViewportDepthClipControlCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT const & - pipelineViewportDepthClipControlCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportDepthClipControlCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportDepthClipControlCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineViewportDepthClipControlCreateInfoEXT.negativeOneToOne ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineViewportExclusiveScissorStateCreateInfoNV { using NativeType = VkPipelineViewportExclusiveScissorStateCreateInfoNV; @@ -75997,28 +71113,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineViewportExclusiveScissorStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineViewportExclusiveScissorStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineViewportExclusiveScissorStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineViewportExclusiveScissorStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, exclusiveScissorCount, pExclusiveScissors ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportExclusiveScissorStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( exclusiveScissorCount == rhs.exclusiveScissorCount ) && ( pExclusiveScissors == rhs.pExclusiveScissors ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -76044,28 +71172,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineViewportExclusiveScissorStateCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV const & - pipelineViewportExclusiveScissorStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportExclusiveScissorStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportExclusiveScissorStateCreateInfoNV.exclusiveScissorCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Rect2D *, - seed, - pipelineViewportExclusiveScissorStateCreateInfoNV.pExclusiveScissors ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ShadingRatePaletteNV { using NativeType = VkShadingRatePaletteNV; @@ -76129,28 +71235,37 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkShadingRatePaletteNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkShadingRatePaletteNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkShadingRatePaletteNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkShadingRatePaletteNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( shadingRatePaletteEntryCount, pShadingRatePaletteEntries ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ShadingRatePaletteNV const & ) const = default; #else bool operator==( ShadingRatePaletteNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( shadingRatePaletteEntryCount == rhs.shadingRatePaletteEntryCount ) && - ( pShadingRatePaletteEntries == rhs.pShadingRatePaletteEntries ); + return this->reflect() == rhs.reflect(); } bool operator!=( ShadingRatePaletteNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -76165,24 +71280,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ShadingRatePaletteNV is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV const & shadingRatePaletteNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shadingRatePaletteNV.shadingRatePaletteEntryCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV *, seed, shadingRatePaletteNV.pShadingRatePaletteEntries ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineViewportShadingRateImageStateCreateInfoNV { using NativeType = VkPipelineViewportShadingRateImageStateCreateInfoNV; @@ -76274,29 +71371,41 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineViewportShadingRateImageStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineViewportShadingRateImageStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineViewportShadingRateImageStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineViewportShadingRateImageStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shadingRateImageEnable, viewportCount, pShadingRatePalettes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportShadingRateImageStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shadingRateImageEnable == rhs.shadingRateImageEnable ) && ( viewportCount == rhs.viewportCount ) && - ( pShadingRatePalettes == rhs.pShadingRatePalettes ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -76323,30 +71432,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineViewportShadingRateImageStateCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV const & - pipelineViewportShadingRateImageStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportShadingRateImageStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportShadingRateImageStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineViewportShadingRateImageStateCreateInfoNV.shadingRateImageEnable ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportShadingRateImageStateCreateInfoNV.viewportCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV *, - seed, - pipelineViewportShadingRateImageStateCreateInfoNV.pShadingRatePalettes ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ViewportSwizzleNV { using NativeType = VkViewportSwizzleNV; @@ -76412,27 +71497,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkViewportSwizzleNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkViewportSwizzleNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkViewportSwizzleNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkViewportSwizzleNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y, z, w ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ViewportSwizzleNV const & ) const = default; #else bool operator==( ViewportSwizzleNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z ) && ( w == rhs.w ); + return this->reflect() == rhs.reflect(); } bool operator!=( ViewportSwizzleNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -76449,24 +71547,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ViewportSwizzleNV is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportSwizzleNV const & viewportSwizzleNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV, seed, viewportSwizzleNV.x ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV, seed, viewportSwizzleNV.y ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV, seed, viewportSwizzleNV.z ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV, seed, viewportSwizzleNV.w ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineViewportSwizzleStateCreateInfoNV { using NativeType = VkPipelineViewportSwizzleStateCreateInfoNV; @@ -76557,28 +71637,41 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineViewportSwizzleStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineViewportSwizzleStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineViewportSwizzleStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineViewportSwizzleStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, viewportCount, pViewportSwizzles ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportSwizzleStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( viewportCount == rhs.viewportCount ) && ( pViewportSwizzles == rhs.pViewportSwizzles ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -76605,31 +71698,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineViewportSwizzleStateCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV const & - pipelineViewportSwizzleStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportSwizzleStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportSwizzleStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateFlagsNV, - seed, - pipelineViewportSwizzleStateCreateInfoNV.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportSwizzleStateCreateInfoNV.viewportCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV *, - seed, - pipelineViewportSwizzleStateCreateInfoNV.pViewportSwizzles ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ViewportWScalingNV { using NativeType = VkViewportWScalingNV; @@ -76669,27 +71737,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkViewportWScalingNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkViewportWScalingNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkViewportWScalingNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkViewportWScalingNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( xcoeff, ycoeff ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ViewportWScalingNV const & ) const = default; #else bool operator==( ViewportWScalingNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( xcoeff == rhs.xcoeff ) && ( ycoeff == rhs.ycoeff ); + return this->reflect() == rhs.reflect(); } bool operator!=( ViewportWScalingNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -76704,23 +71782,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ViewportWScalingNV is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ViewportWScalingNV const & viewportWScalingNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( float, seed, viewportWScalingNV.xcoeff ); - VULKAN_HPP_HASH_COMBINE( float, seed, viewportWScalingNV.ycoeff ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PipelineViewportWScalingStateCreateInfoNV { using NativeType = VkPipelineViewportWScalingStateCreateInfoNV; @@ -76811,29 +71872,41 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPipelineViewportWScalingStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineViewportWScalingStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPipelineViewportWScalingStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkPipelineViewportWScalingStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, viewportWScalingEnable, viewportCount, pViewportWScalings ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportWScalingStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineViewportWScalingStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( viewportWScalingEnable == rhs.viewportWScalingEnable ) && ( viewportCount == rhs.viewportCount ) && - ( pViewportWScalings == rhs.pViewportWScalings ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineViewportWScalingStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -76860,30 +71933,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineViewportWScalingStateCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV const & - pipelineViewportWScalingStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, pipelineViewportWScalingStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, pipelineViewportWScalingStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, pipelineViewportWScalingStateCreateInfoNV.viewportWScalingEnable ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, pipelineViewportWScalingStateCreateInfoNV.viewportCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ViewportWScalingNV *, - seed, - pipelineViewportWScalingStateCreateInfoNV.pViewportWScalings ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_GGP ) struct PresentFrameTokenGGP { @@ -76926,28 +71975,37 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPresentFrameTokenGGP const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPresentFrameTokenGGP const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPresentFrameTokenGGP &() VULKAN_HPP_NOEXCEPT + explicit operator VkPresentFrameTokenGGP &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, frameToken ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentFrameTokenGGP const & ) const = default; # else bool operator==( PresentFrameTokenGGP const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( memcmp( &frameToken, &rhs.frameToken, sizeof( GgpFrameToken ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PresentFrameTokenGGP const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -76968,25 +72026,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = PresentFrameTokenGGP; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP const & presentFrameTokenGGP ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentFrameTokenGGP.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, presentFrameTokenGGP.pNext ); - VULKAN_HPP_HASH_COMBINE( GgpFrameToken, seed, presentFrameTokenGGP.frameToken ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_GGP*/ struct PresentIdKHR @@ -77054,28 +72093,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPresentIdKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPresentIdKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPresentIdKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPresentIdKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchainCount, pPresentIds ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentIdKHR const & ) const = default; #else bool operator==( PresentIdKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && - ( pPresentIds == rhs.pPresentIds ); + return this->reflect() == rhs.reflect(); } bool operator!=( PresentIdKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -77098,24 +72149,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PresentIdKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentIdKHR const & presentIdKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentIdKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, presentIdKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentIdKHR.swapchainCount ); - VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, presentIdKHR.pPresentIds ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PresentInfoKHR { using NativeType = VkPresentInfoKHR; @@ -77280,30 +72313,45 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPresentInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPresentInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, waitSemaphoreCount, pWaitSemaphores, swapchainCount, pSwapchains, pImageIndices, pResults ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentInfoKHR const & ) const = default; #else bool operator==( PresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) && - ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( swapchainCount == rhs.swapchainCount ) && - ( pSwapchains == rhs.pSwapchains ) && ( pImageIndices == rhs.pImageIndices ) && - ( pResults == rhs.pResults ); + return this->reflect() == rhs.reflect(); } bool operator!=( PresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -77330,28 +72378,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PresentInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentInfoKHR const & presentInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, presentInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentInfoKHR.waitSemaphoreCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, presentInfoKHR.pWaitSemaphores ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentInfoKHR.swapchainCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SwapchainKHR *, seed, presentInfoKHR.pSwapchains ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, presentInfoKHR.pImageIndices ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Result *, seed, presentInfoKHR.pResults ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct RectLayerKHR { using NativeType = VkRectLayerKHR; @@ -77406,27 +72432,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRectLayerKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRectLayerKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRectLayerKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkRectLayerKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( offset, extent, layer ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RectLayerKHR const & ) const = default; #else bool operator==( RectLayerKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( offset == rhs.offset ) && ( extent == rhs.extent ) && ( layer == rhs.layer ); + return this->reflect() == rhs.reflect(); } bool operator!=( RectLayerKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -77442,23 +72478,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "RectLayerKHR is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::RectLayerKHR const & rectLayerKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, rectLayerKHR.offset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, rectLayerKHR.extent ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rectLayerKHR.layer ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PresentRegionKHR { using NativeType = VkPresentRegionKHR; @@ -77519,27 +72538,37 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPresentRegionKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPresentRegionKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPresentRegionKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPresentRegionKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( rectangleCount, pRectangles ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentRegionKHR const & ) const = default; #else bool operator==( PresentRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( rectangleCount == rhs.rectangleCount ) && ( pRectangles == rhs.pRectangles ); + return this->reflect() == rhs.reflect(); } bool operator!=( PresentRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -77554,22 +72583,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "PresentRegionKHR is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionKHR const & presentRegionKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentRegionKHR.rectangleCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::RectLayerKHR *, seed, presentRegionKHR.pRectangles ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PresentRegionsKHR { using NativeType = VkPresentRegionsKHR; @@ -77639,28 +72652,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPresentRegionsKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPresentRegionsKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPresentRegionsKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkPresentRegionsKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchainCount, pRegions ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentRegionsKHR const & ) const = default; #else bool operator==( PresentRegionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && - ( pRegions == rhs.pRegions ); + return this->reflect() == rhs.reflect(); } bool operator!=( PresentRegionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -77683,24 +72708,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PresentRegionsKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionsKHR const & presentRegionsKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentRegionsKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, presentRegionsKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentRegionsKHR.swapchainCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PresentRegionKHR *, seed, presentRegionsKHR.pRegions ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PresentTimeGOOGLE { using NativeType = VkPresentTimeGOOGLE; @@ -77742,27 +72749,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPresentTimeGOOGLE const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPresentTimeGOOGLE const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPresentTimeGOOGLE &() VULKAN_HPP_NOEXCEPT + explicit operator VkPresentTimeGOOGLE &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( presentID, desiredPresentTime ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentTimeGOOGLE const & ) const = default; #else bool operator==( PresentTimeGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( presentID == rhs.presentID ) && ( desiredPresentTime == rhs.desiredPresentTime ); + return this->reflect() == rhs.reflect(); } bool operator!=( PresentTimeGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -77777,22 +72794,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "PresentTimeGOOGLE is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE const & presentTimeGOOGLE ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentTimeGOOGLE.presentID ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, presentTimeGOOGLE.desiredPresentTime ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PresentTimesInfoGOOGLE { using NativeType = VkPresentTimesInfoGOOGLE; @@ -77862,28 +72863,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPresentTimesInfoGOOGLE const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPresentTimesInfoGOOGLE const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPresentTimesInfoGOOGLE &() VULKAN_HPP_NOEXCEPT + explicit operator VkPresentTimesInfoGOOGLE &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchainCount, pTimes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentTimesInfoGOOGLE const & ) const = default; #else bool operator==( PresentTimesInfoGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && - ( pTimes == rhs.pTimes ); + return this->reflect() == rhs.reflect(); } bool operator!=( PresentTimesInfoGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -77907,25 +72920,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PresentTimesInfoGOOGLE; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE const & presentTimesInfoGOOGLE ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, presentTimesInfoGOOGLE.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, presentTimesInfoGOOGLE.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, presentTimesInfoGOOGLE.swapchainCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE *, seed, presentTimesInfoGOOGLE.pTimes ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct PrivateDataSlotCreateInfoEXT { using NativeType = VkPrivateDataSlotCreateInfoEXT; @@ -77969,27 +72963,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkPrivateDataSlotCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkPrivateDataSlotCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkPrivateDataSlotCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkPrivateDataSlotCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PrivateDataSlotCreateInfoEXT const & ) const = default; #else bool operator==( PrivateDataSlotCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( PrivateDataSlotCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -78013,25 +73019,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = PrivateDataSlotCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT const & privateDataSlotCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, privateDataSlotCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, privateDataSlotCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagsEXT, seed, privateDataSlotCreateInfoEXT.flags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ProtectedSubmitInfo { using NativeType = VkProtectedSubmitInfo; @@ -78074,27 +73061,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkProtectedSubmitInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkProtectedSubmitInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkProtectedSubmitInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkProtectedSubmitInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, protectedSubmit ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ProtectedSubmitInfo const & ) const = default; #else bool operator==( ProtectedSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedSubmit == rhs.protectedSubmit ); + return this->reflect() == rhs.reflect(); } bool operator!=( ProtectedSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -78116,24 +73113,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ProtectedSubmitInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo const & protectedSubmitInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, protectedSubmitInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, protectedSubmitInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, protectedSubmitInfo.protectedSubmit ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct QueryPoolCreateInfo { using NativeType = VkQueryPoolCreateInfo; @@ -78203,29 +73182,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkQueryPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkQueryPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkQueryPoolCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkQueryPoolCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, queryType, queryCount, pipelineStatistics ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueryPoolCreateInfo const & ) const = default; #else bool operator==( QueryPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( queryType == rhs.queryType ) && ( queryCount == rhs.queryCount ) && - ( pipelineStatistics == rhs.pipelineStatistics ); + return this->reflect() == rhs.reflect(); } bool operator!=( QueryPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -78250,28 +73242,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = QueryPoolCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & queryPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queryPoolCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, queryPoolCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueryPoolCreateFlags, seed, queryPoolCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueryType, seed, queryPoolCreateInfo.queryType ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queryPoolCreateInfo.queryCount ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags, seed, queryPoolCreateInfo.pipelineStatistics ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct QueryPoolPerformanceCreateInfoKHR { using NativeType = VkQueryPoolPerformanceCreateInfoKHR; @@ -78355,28 +73325,41 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkQueryPoolPerformanceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkQueryPoolPerformanceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkQueryPoolPerformanceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkQueryPoolPerformanceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, queueFamilyIndex, counterIndexCount, pCounterIndices ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueryPoolPerformanceCreateInfoKHR const & ) const = default; #else bool operator==( QueryPoolPerformanceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) && - ( counterIndexCount == rhs.counterIndexCount ) && ( pCounterIndices == rhs.pCounterIndices ); + return this->reflect() == rhs.reflect(); } bool operator!=( QueryPoolPerformanceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -78402,26 +73385,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = QueryPoolPerformanceCreateInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR const & - queryPoolPerformanceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queryPoolPerformanceCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, queryPoolPerformanceCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queryPoolPerformanceCreateInfoKHR.queueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queryPoolPerformanceCreateInfoKHR.counterIndexCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, queryPoolPerformanceCreateInfoKHR.pCounterIndices ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct QueryPoolPerformanceQueryCreateInfoINTEL { using NativeType = VkQueryPoolPerformanceQueryCreateInfoINTEL; @@ -78473,28 +73436,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkQueryPoolPerformanceQueryCreateInfoINTEL const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkQueryPoolPerformanceQueryCreateInfoINTEL const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkQueryPoolPerformanceQueryCreateInfoINTEL &() VULKAN_HPP_NOEXCEPT + explicit operator VkQueryPoolPerformanceQueryCreateInfoINTEL &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, performanceCountersSampling ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueryPoolPerformanceQueryCreateInfoINTEL const & ) const = default; #else bool operator==( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( performanceCountersSampling == rhs.performanceCountersSampling ); + return this->reflect() == rhs.reflect(); } bool operator!=( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -78521,27 +73495,6 @@ namespace VULKAN_HPP_NAMESPACE }; using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL const & - queryPoolPerformanceQueryCreateInfoINTEL ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, queryPoolPerformanceQueryCreateInfoINTEL.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, queryPoolPerformanceQueryCreateInfoINTEL.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL, - seed, - queryPoolPerformanceQueryCreateInfoINTEL.performanceCountersSampling ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct QueueFamilyCheckpointProperties2NV { using NativeType = VkQueueFamilyCheckpointProperties2NV; @@ -78574,28 +73527,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkQueueFamilyCheckpointProperties2NV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkQueueFamilyCheckpointProperties2NV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkQueueFamilyCheckpointProperties2NV &() VULKAN_HPP_NOEXCEPT + explicit operator VkQueueFamilyCheckpointProperties2NV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, checkpointExecutionStageMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueueFamilyCheckpointProperties2NV const & ) const = default; #else bool operator==( QueueFamilyCheckpointProperties2NV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( QueueFamilyCheckpointProperties2NV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -78619,26 +73583,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = QueueFamilyCheckpointProperties2NV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV const & - queueFamilyCheckpointProperties2NV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queueFamilyCheckpointProperties2NV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, queueFamilyCheckpointProperties2NV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, - seed, - queueFamilyCheckpointProperties2NV.checkpointExecutionStageMask ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct QueueFamilyCheckpointPropertiesNV { using NativeType = VkQueueFamilyCheckpointPropertiesNV; @@ -78670,28 +73614,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkQueueFamilyCheckpointPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkQueueFamilyCheckpointPropertiesNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkQueueFamilyCheckpointPropertiesNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkQueueFamilyCheckpointPropertiesNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, checkpointExecutionStageMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueueFamilyCheckpointPropertiesNV const & ) const = default; #else bool operator==( QueueFamilyCheckpointPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( QueueFamilyCheckpointPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -78715,25 +73670,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = QueueFamilyCheckpointPropertiesNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV const & - queueFamilyCheckpointPropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queueFamilyCheckpointPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, queueFamilyCheckpointPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, queueFamilyCheckpointPropertiesNV.checkpointExecutionStageMask ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct QueueFamilyGlobalPriorityPropertiesEXT { using NativeType = VkQueueFamilyGlobalPriorityPropertiesEXT; @@ -78808,28 +73744,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkQueueFamilyGlobalPriorityPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkQueueFamilyGlobalPriorityPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkQueueFamilyGlobalPriorityPropertiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkQueueFamilyGlobalPriorityPropertiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, priorityCount, priorities ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueueFamilyGlobalPriorityPropertiesEXT const & ) const = default; #else bool operator==( QueueFamilyGlobalPriorityPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priorityCount == rhs.priorityCount ) && - ( priorities == rhs.priorities ); + return this->reflect() == rhs.reflect(); } bool operator!=( QueueFamilyGlobalPriorityPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -78856,29 +73805,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = QueueFamilyGlobalPriorityPropertiesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesEXT const & - queueFamilyGlobalPriorityPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queueFamilyGlobalPriorityPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, queueFamilyGlobalPriorityPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queueFamilyGlobalPriorityPropertiesEXT.priorityCount ); - for ( size_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_EXT; ++i ) - { - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT, seed, queueFamilyGlobalPriorityPropertiesEXT.priorities[i] ); - } - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct QueueFamilyProperties { using NativeType = VkQueueFamilyProperties; @@ -78910,29 +73836,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkQueueFamilyProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkQueueFamilyProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkQueueFamilyProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkQueueFamilyProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( queueFlags, queueCount, timestampValidBits, minImageTransferGranularity ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueueFamilyProperties const & ) const = default; #else bool operator==( QueueFamilyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( queueFlags == rhs.queueFlags ) && ( queueCount == rhs.queueCount ) && - ( timestampValidBits == rhs.timestampValidBits ) && - ( minImageTransferGranularity == rhs.minImageTransferGranularity ); + return this->reflect() == rhs.reflect(); } bool operator!=( QueueFamilyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -78949,25 +73886,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "QueueFamilyProperties is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties const & queueFamilyProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::QueueFlags, seed, queueFamilyProperties.queueFlags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queueFamilyProperties.queueCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, queueFamilyProperties.timestampValidBits ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, queueFamilyProperties.minImageTransferGranularity ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct QueueFamilyProperties2 { using NativeType = VkQueueFamilyProperties2; @@ -78996,27 +73914,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkQueueFamilyProperties2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkQueueFamilyProperties2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkQueueFamilyProperties2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkQueueFamilyProperties2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, queueFamilyProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueueFamilyProperties2 const & ) const = default; #else bool operator==( QueueFamilyProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyProperties == rhs.queueFamilyProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( QueueFamilyProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -79040,25 +73970,112 @@ namespace VULKAN_HPP_NAMESPACE }; using QueueFamilyProperties2KHR = QueueFamilyProperties2; -} // namespace VULKAN_HPP_NAMESPACE +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + struct QueueFamilyQueryResultStatusProperties2KHR + { + using NativeType = VkQueueFamilyQueryResultStatusProperties2KHR; -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 const & queueFamilyProperties2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, queueFamilyProperties2.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, queueFamilyProperties2.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::QueueFamilyProperties, seed, queueFamilyProperties2.queueFamilyProperties ); - return seed; - } -}; + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eQueueFamilyQueryResultStatusProperties2KHR; + +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + QueueFamilyQueryResultStatusProperties2KHR( VULKAN_HPP_NAMESPACE::Bool32 supported_ = {} ) VULKAN_HPP_NOEXCEPT + : supported( supported_ ) + {} + + VULKAN_HPP_CONSTEXPR QueueFamilyQueryResultStatusProperties2KHR( + QueueFamilyQueryResultStatusProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + QueueFamilyQueryResultStatusProperties2KHR( VkQueueFamilyQueryResultStatusProperties2KHR const & rhs ) + VULKAN_HPP_NOEXCEPT + : QueueFamilyQueryResultStatusProperties2KHR( + *reinterpret_cast( &rhs ) ) + {} +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + QueueFamilyQueryResultStatusProperties2KHR & + operator=( QueueFamilyQueryResultStatusProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + QueueFamilyQueryResultStatusProperties2KHR & + operator=( VkQueueFamilyQueryResultStatusProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 QueueFamilyQueryResultStatusProperties2KHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 QueueFamilyQueryResultStatusProperties2KHR & + setSupported( VULKAN_HPP_NAMESPACE::Bool32 supported_ ) VULKAN_HPP_NOEXCEPT + { + supported = supported_; + return *this; + } +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + explicit operator VkQueueFamilyQueryResultStatusProperties2KHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + explicit operator VkQueueFamilyQueryResultStatusProperties2KHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, supported ); + } + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( QueueFamilyQueryResultStatusProperties2KHR const & ) const = default; +# else + bool operator==( QueueFamilyQueryResultStatusProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return this->reflect() == rhs.reflect(); + } + + bool operator!=( QueueFamilyQueryResultStatusProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return this->reflect() != rhs.reflect(); + } +# endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eQueueFamilyQueryResultStatusProperties2KHR; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 supported = {}; + }; + VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusProperties2KHR ) == + sizeof( VkQueueFamilyQueryResultStatusProperties2KHR ), + "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, + "QueueFamilyQueryResultStatusProperties2KHR is not nothrow_move_constructible!" ); + + template <> + struct CppType + { + using Type = QueueFamilyQueryResultStatusProperties2KHR; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ -namespace VULKAN_HPP_NAMESPACE -{ struct RayTracingShaderGroupCreateInfoKHR { using NativeType = VkRayTracingShaderGroupCreateInfoKHR; @@ -79152,30 +74169,51 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRayTracingShaderGroupCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRayTracingShaderGroupCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRayTracingShaderGroupCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkRayTracingShaderGroupCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + type, + generalShader, + closestHitShader, + anyHitShader, + intersectionShader, + pShaderGroupCaptureReplayHandle ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RayTracingShaderGroupCreateInfoKHR const & ) const = default; #else bool operator==( RayTracingShaderGroupCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && - ( generalShader == rhs.generalShader ) && ( closestHitShader == rhs.closestHitShader ) && - ( anyHitShader == rhs.anyHitShader ) && ( intersectionShader == rhs.intersectionShader ) && - ( pShaderGroupCaptureReplayHandle == rhs.pShaderGroupCaptureReplayHandle ); + return this->reflect() == rhs.reflect(); } bool operator!=( RayTracingShaderGroupCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -79205,30 +74243,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = RayTracingShaderGroupCreateInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR const & - rayTracingShaderGroupCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingShaderGroupCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingShaderGroupCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR, seed, rayTracingShaderGroupCreateInfoKHR.type ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoKHR.generalShader ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoKHR.closestHitShader ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoKHR.anyHitShader ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoKHR.intersectionShader ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingShaderGroupCreateInfoKHR.pShaderGroupCaptureReplayHandle ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct RayTracingPipelineInterfaceCreateInfoKHR { using NativeType = VkRayTracingPipelineInterfaceCreateInfoKHR; @@ -79288,29 +74302,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRayTracingPipelineInterfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRayTracingPipelineInterfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRayTracingPipelineInterfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkRayTracingPipelineInterfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxPipelineRayPayloadSize, maxPipelineRayHitAttributeSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RayTracingPipelineInterfaceCreateInfoKHR const & ) const = default; #else bool operator==( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxPipelineRayPayloadSize == rhs.maxPipelineRayPayloadSize ) && - ( maxPipelineRayHitAttributeSize == rhs.maxPipelineRayHitAttributeSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -79336,26 +74358,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = RayTracingPipelineInterfaceCreateInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR const & - rayTracingPipelineInterfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingPipelineInterfaceCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingPipelineInterfaceCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayPayloadSize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayHitAttributeSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct RayTracingPipelineCreateInfoKHR { using NativeType = VkRayTracingPipelineCreateInfoKHR; @@ -79549,32 +74551,63 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRayTracingPipelineCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRayTracingPipelineCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRayTracingPipelineCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkRayTracingPipelineCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + stageCount, + pStages, + groupCount, + pGroups, + maxPipelineRayRecursionDepth, + pLibraryInfo, + pLibraryInterface, + pDynamicState, + layout, + basePipelineHandle, + basePipelineIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RayTracingPipelineCreateInfoKHR const & ) const = default; #else bool operator==( RayTracingPipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && ( groupCount == rhs.groupCount ) && - ( pGroups == rhs.pGroups ) && ( maxPipelineRayRecursionDepth == rhs.maxPipelineRayRecursionDepth ) && - ( pLibraryInfo == rhs.pLibraryInfo ) && ( pLibraryInterface == rhs.pLibraryInterface ) && - ( pDynamicState == rhs.pDynamicState ) && ( layout == rhs.layout ) && - ( basePipelineHandle == rhs.basePipelineHandle ) && ( basePipelineIndex == rhs.basePipelineIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( RayTracingPipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -79609,43 +74642,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = RayTracingPipelineCreateInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & rayTracingPipelineCreateInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingPipelineCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingPipelineCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreateFlags, seed, rayTracingPipelineCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoKHR.stageCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo *, seed, rayTracingPipelineCreateInfoKHR.pStages ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoKHR.groupCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR *, seed, rayTracingPipelineCreateInfoKHR.pGroups ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoKHR.maxPipelineRayRecursionDepth ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR *, seed, rayTracingPipelineCreateInfoKHR.pLibraryInfo ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR *, - seed, - rayTracingPipelineCreateInfoKHR.pLibraryInterface ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo *, - seed, - rayTracingPipelineCreateInfoKHR.pDynamicState ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayout, seed, rayTracingPipelineCreateInfoKHR.layout ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, rayTracingPipelineCreateInfoKHR.basePipelineHandle ); - VULKAN_HPP_HASH_COMBINE( int32_t, seed, rayTracingPipelineCreateInfoKHR.basePipelineIndex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct RayTracingShaderGroupCreateInfoNV { using NativeType = VkRayTracingShaderGroupCreateInfoNV; @@ -79729,29 +74725,43 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRayTracingShaderGroupCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRayTracingShaderGroupCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRayTracingShaderGroupCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkRayTracingShaderGroupCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type, generalShader, closestHitShader, anyHitShader, intersectionShader ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RayTracingShaderGroupCreateInfoNV const & ) const = default; #else bool operator==( RayTracingShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && - ( generalShader == rhs.generalShader ) && ( closestHitShader == rhs.closestHitShader ) && - ( anyHitShader == rhs.anyHitShader ) && ( intersectionShader == rhs.intersectionShader ); + return this->reflect() == rhs.reflect(); } bool operator!=( RayTracingShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -79780,29 +74790,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = RayTracingShaderGroupCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV const & - rayTracingShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingShaderGroupCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingShaderGroupCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR, seed, rayTracingShaderGroupCreateInfoNV.type ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoNV.generalShader ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoNV.closestHitShader ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoNV.anyHitShader ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingShaderGroupCreateInfoNV.intersectionShader ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct RayTracingPipelineCreateInfoNV { using NativeType = VkRayTracingPipelineCreateInfoNV; @@ -79963,30 +74950,57 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRayTracingPipelineCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRayTracingPipelineCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRayTracingPipelineCreateInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkRayTracingPipelineCreateInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + stageCount, + pStages, + groupCount, + pGroups, + maxRecursionDepth, + layout, + basePipelineHandle, + basePipelineIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RayTracingPipelineCreateInfoNV const & ) const = default; #else bool operator==( RayTracingPipelineCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && ( groupCount == rhs.groupCount ) && - ( pGroups == rhs.pGroups ) && ( maxRecursionDepth == rhs.maxRecursionDepth ) && ( layout == rhs.layout ) && - ( basePipelineHandle == rhs.basePipelineHandle ) && ( basePipelineIndex == rhs.basePipelineIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( RayTracingPipelineCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -80018,34 +75032,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = RayTracingPipelineCreateInfoNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & rayTracingPipelineCreateInfoNV ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, rayTracingPipelineCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, rayTracingPipelineCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineCreateFlags, seed, rayTracingPipelineCreateInfoNV.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoNV.stageCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo *, seed, rayTracingPipelineCreateInfoNV.pStages ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoNV.groupCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV *, seed, rayTracingPipelineCreateInfoNV.pGroups ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, rayTracingPipelineCreateInfoNV.maxRecursionDepth ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineLayout, seed, rayTracingPipelineCreateInfoNV.layout ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Pipeline, seed, rayTracingPipelineCreateInfoNV.basePipelineHandle ); - VULKAN_HPP_HASH_COMBINE( int32_t, seed, rayTracingPipelineCreateInfoNV.basePipelineIndex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct RefreshCycleDurationGOOGLE { using NativeType = VkRefreshCycleDurationGOOGLE; @@ -80071,27 +75057,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkRefreshCycleDurationGOOGLE const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRefreshCycleDurationGOOGLE const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRefreshCycleDurationGOOGLE &() VULKAN_HPP_NOEXCEPT + explicit operator VkRefreshCycleDurationGOOGLE &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( refreshDuration ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RefreshCycleDurationGOOGLE const & ) const = default; #else bool operator==( RefreshCycleDurationGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( refreshDuration == rhs.refreshDuration ); + return this->reflect() == rhs.reflect(); } bool operator!=( RefreshCycleDurationGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -80106,22 +75102,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "RefreshCycleDurationGOOGLE is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE const & refreshCycleDurationGOOGLE ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, refreshCycleDurationGOOGLE.refreshDuration ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct RenderPassAttachmentBeginInfo { using NativeType = VkRenderPassAttachmentBeginInfo; @@ -80194,28 +75174,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRenderPassAttachmentBeginInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRenderPassAttachmentBeginInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRenderPassAttachmentBeginInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkRenderPassAttachmentBeginInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, attachmentCount, pAttachments ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassAttachmentBeginInfo const & ) const = default; #else bool operator==( RenderPassAttachmentBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentCount == rhs.attachmentCount ) && - ( pAttachments == rhs.pAttachments ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderPassAttachmentBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -80241,26 +75233,6 @@ namespace VULKAN_HPP_NAMESPACE }; using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo const & renderPassAttachmentBeginInfo ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassAttachmentBeginInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassAttachmentBeginInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassAttachmentBeginInfo.attachmentCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::ImageView *, seed, renderPassAttachmentBeginInfo.pAttachments ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct RenderPassBeginInfo { using NativeType = VkRenderPassBeginInfo; @@ -80364,29 +75336,43 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRenderPassBeginInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRenderPassBeginInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRenderPassBeginInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkRenderPassBeginInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, renderPass, framebuffer, renderArea, clearValueCount, pClearValues ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassBeginInfo const & ) const = default; #else bool operator==( RenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) && - ( framebuffer == rhs.framebuffer ) && ( renderArea == rhs.renderArea ) && - ( clearValueCount == rhs.clearValueCount ) && ( pClearValues == rhs.pClearValues ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -80412,28 +75398,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = RenderPassBeginInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::RenderPassBeginInfo const & renderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassBeginInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassBeginInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPass, seed, renderPassBeginInfo.renderPass ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Framebuffer, seed, renderPassBeginInfo.framebuffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, renderPassBeginInfo.renderArea ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassBeginInfo.clearValueCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ClearValue *, seed, renderPassBeginInfo.pClearValues ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SubpassDescription { using NativeType = VkSubpassDescription; @@ -80628,33 +75592,55 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSubpassDescription const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSubpassDescription const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSubpassDescription &() VULKAN_HPP_NOEXCEPT + explicit operator VkSubpassDescription &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( flags, + pipelineBindPoint, + inputAttachmentCount, + pInputAttachments, + colorAttachmentCount, + pColorAttachments, + pResolveAttachments, + pDepthStencilAttachment, + preserveAttachmentCount, + pPreserveAttachments ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassDescription const & ) const = default; #else bool operator==( SubpassDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && - ( inputAttachmentCount == rhs.inputAttachmentCount ) && ( pInputAttachments == rhs.pInputAttachments ) && - ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachments == rhs.pColorAttachments ) && - ( pResolveAttachments == rhs.pResolveAttachments ) && - ( pDepthStencilAttachment == rhs.pDepthStencilAttachment ) && - ( preserveAttachmentCount == rhs.preserveAttachmentCount ) && - ( pPreserveAttachments == rhs.pPreserveAttachments ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubpassDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -80677,35 +75663,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SubpassDescription is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SubpassDescription const & subpassDescription ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags, seed, subpassDescription.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, subpassDescription.pipelineBindPoint ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription.inputAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::AttachmentReference *, seed, subpassDescription.pInputAttachments ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription.colorAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::AttachmentReference *, seed, subpassDescription.pColorAttachments ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::AttachmentReference *, seed, subpassDescription.pResolveAttachments ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::AttachmentReference *, seed, subpassDescription.pDepthStencilAttachment ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription.preserveAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, subpassDescription.pPreserveAttachments ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SubpassDependency { using NativeType = VkSubpassDependency; @@ -80792,30 +75749,44 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSubpassDependency const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSubpassDependency const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSubpassDependency &() VULKAN_HPP_NOEXCEPT + explicit operator VkSubpassDependency &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + srcSubpass, dstSubpass, srcStageMask, dstStageMask, srcAccessMask, dstAccessMask, dependencyFlags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassDependency const & ) const = default; #else bool operator==( SubpassDependency const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( srcSubpass == rhs.srcSubpass ) && ( dstSubpass == rhs.dstSubpass ) && - ( srcStageMask == rhs.srcStageMask ) && ( dstStageMask == rhs.dstStageMask ) && - ( srcAccessMask == rhs.srcAccessMask ) && ( dstAccessMask == rhs.dstAccessMask ) && - ( dependencyFlags == rhs.dependencyFlags ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubpassDependency const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -80835,27 +75806,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SubpassDependency is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency const & subpassDependency ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDependency.srcSubpass ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDependency.dstSubpass ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, subpassDependency.srcStageMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, subpassDependency.dstStageMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, subpassDependency.srcAccessMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, subpassDependency.dstAccessMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DependencyFlags, seed, subpassDependency.dependencyFlags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct RenderPassCreateInfo { using NativeType = VkRenderPassCreateInfo; @@ -81002,30 +75952,46 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRenderPassCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRenderPassCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRenderPassCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkRenderPassCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, flags, attachmentCount, pAttachments, subpassCount, pSubpasses, dependencyCount, pDependencies ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassCreateInfo const & ) const = default; #else bool operator==( RenderPassCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ) && - ( subpassCount == rhs.subpassCount ) && ( pSubpasses == rhs.pSubpasses ) && - ( dependencyCount == rhs.dependencyCount ) && ( pDependencies == rhs.pDependencies ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderPassCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -81053,32 +76019,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = RenderPassCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & renderPassCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPassCreateFlags, seed, renderPassCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo.attachmentCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::AttachmentDescription *, seed, renderPassCreateInfo.pAttachments ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo.subpassCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SubpassDescription *, seed, renderPassCreateInfo.pSubpasses ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo.dependencyCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::SubpassDependency *, seed, renderPassCreateInfo.pDependencies ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SubpassDescription2 { using NativeType = VkSubpassDescription2; @@ -81292,34 +76232,61 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSubpassDescription2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSubpassDescription2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSubpassDescription2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkSubpassDescription2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + pipelineBindPoint, + viewMask, + inputAttachmentCount, + pInputAttachments, + colorAttachmentCount, + pColorAttachments, + pResolveAttachments, + pDepthStencilAttachment, + preserveAttachmentCount, + pPreserveAttachments ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassDescription2 const & ) const = default; #else bool operator==( SubpassDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( viewMask == rhs.viewMask ) && - ( inputAttachmentCount == rhs.inputAttachmentCount ) && ( pInputAttachments == rhs.pInputAttachments ) && - ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachments == rhs.pColorAttachments ) && - ( pResolveAttachments == rhs.pResolveAttachments ) && - ( pDepthStencilAttachment == rhs.pDepthStencilAttachment ) && - ( preserveAttachmentCount == rhs.preserveAttachmentCount ) && - ( pPreserveAttachments == rhs.pPreserveAttachments ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubpassDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -81352,38 +76319,6 @@ namespace VULKAN_HPP_NAMESPACE }; using SubpassDescription2KHR = SubpassDescription2; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SubpassDescription2 const & subpassDescription2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassDescription2.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassDescription2.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags, seed, subpassDescription2.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineBindPoint, seed, subpassDescription2.pipelineBindPoint ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription2.viewMask ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription2.inputAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::AttachmentReference2 *, seed, subpassDescription2.pInputAttachments ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription2.colorAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::AttachmentReference2 *, seed, subpassDescription2.pColorAttachments ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::AttachmentReference2 *, seed, subpassDescription2.pResolveAttachments ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::AttachmentReference2 *, seed, subpassDescription2.pDepthStencilAttachment ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDescription2.preserveAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, subpassDescription2.pPreserveAttachments ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SubpassDependency2 { using NativeType = VkSubpassDependency2; @@ -81486,31 +76421,55 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSubpassDependency2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSubpassDependency2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSubpassDependency2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkSubpassDependency2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + srcSubpass, + dstSubpass, + srcStageMask, + dstStageMask, + srcAccessMask, + dstAccessMask, + dependencyFlags, + viewOffset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassDependency2 const & ) const = default; #else bool operator==( SubpassDependency2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubpass == rhs.srcSubpass ) && - ( dstSubpass == rhs.dstSubpass ) && ( srcStageMask == rhs.srcStageMask ) && - ( dstStageMask == rhs.dstStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) && - ( dstAccessMask == rhs.dstAccessMask ) && ( dependencyFlags == rhs.dependencyFlags ) && - ( viewOffset == rhs.viewOffset ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubpassDependency2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -81540,31 +76499,6 @@ namespace VULKAN_HPP_NAMESPACE }; using SubpassDependency2KHR = SubpassDependency2; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SubpassDependency2 const & subpassDependency2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassDependency2.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassDependency2.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDependency2.srcSubpass ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassDependency2.dstSubpass ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, subpassDependency2.srcStageMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags, seed, subpassDependency2.dstStageMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, subpassDependency2.srcAccessMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AccessFlags, seed, subpassDependency2.dstAccessMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DependencyFlags, seed, subpassDependency2.dependencyFlags ); - VULKAN_HPP_HASH_COMBINE( int32_t, seed, subpassDependency2.viewOffset ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct RenderPassCreateInfo2 { using NativeType = VkRenderPassCreateInfo2; @@ -81741,32 +76675,57 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRenderPassCreateInfo2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRenderPassCreateInfo2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRenderPassCreateInfo2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkRenderPassCreateInfo2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + attachmentCount, + pAttachments, + subpassCount, + pSubpasses, + dependencyCount, + pDependencies, + correlatedViewMaskCount, + pCorrelatedViewMasks ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassCreateInfo2 const & ) const = default; #else bool operator==( RenderPassCreateInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ) && - ( subpassCount == rhs.subpassCount ) && ( pSubpasses == rhs.pSubpasses ) && - ( dependencyCount == rhs.dependencyCount ) && ( pDependencies == rhs.pDependencies ) && - ( correlatedViewMaskCount == rhs.correlatedViewMaskCount ) && - ( pCorrelatedViewMasks == rhs.pCorrelatedViewMasks ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderPassCreateInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -81797,35 +76756,6 @@ namespace VULKAN_HPP_NAMESPACE }; using RenderPassCreateInfo2KHR = RenderPassCreateInfo2; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & renderPassCreateInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassCreateInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassCreateInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderPassCreateFlags, seed, renderPassCreateInfo2.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo2.attachmentCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::AttachmentDescription2 *, seed, renderPassCreateInfo2.pAttachments ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo2.subpassCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::SubpassDescription2 *, seed, renderPassCreateInfo2.pSubpasses ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo2.dependencyCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::SubpassDependency2 *, seed, renderPassCreateInfo2.pDependencies ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassCreateInfo2.correlatedViewMaskCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, renderPassCreateInfo2.pCorrelatedViewMasks ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct RenderPassFragmentDensityMapCreateInfoEXT { using NativeType = VkRenderPassFragmentDensityMapCreateInfoEXT; @@ -81876,28 +76806,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRenderPassFragmentDensityMapCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRenderPassFragmentDensityMapCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRenderPassFragmentDensityMapCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkRenderPassFragmentDensityMapCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentDensityMapAttachment ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassFragmentDensityMapCreateInfoEXT const & ) const = default; #else bool operator==( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( fragmentDensityMapAttachment == rhs.fragmentDensityMapAttachment ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -81922,27 +76863,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = RenderPassFragmentDensityMapCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT const & - renderPassFragmentDensityMapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassFragmentDensityMapCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassFragmentDensityMapCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::AttachmentReference, - seed, - renderPassFragmentDensityMapCreateInfoEXT.fragmentDensityMapAttachment ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct RenderPassInputAttachmentAspectCreateInfo { using NativeType = VkRenderPassInputAttachmentAspectCreateInfo; @@ -82022,28 +76942,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRenderPassInputAttachmentAspectCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRenderPassInputAttachmentAspectCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRenderPassInputAttachmentAspectCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkRenderPassInputAttachmentAspectCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, aspectReferenceCount, pAspectReferences ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassInputAttachmentAspectCreateInfo const & ) const = default; #else bool operator==( RenderPassInputAttachmentAspectCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aspectReferenceCount == rhs.aspectReferenceCount ) && - ( pAspectReferences == rhs.pAspectReferences ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderPassInputAttachmentAspectCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -82070,28 +77002,6 @@ namespace VULKAN_HPP_NAMESPACE }; using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo const & - renderPassInputAttachmentAspectCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassInputAttachmentAspectCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassInputAttachmentAspectCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassInputAttachmentAspectCreateInfo.aspectReferenceCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference *, - seed, - renderPassInputAttachmentAspectCreateInfo.pAspectReferences ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct RenderPassMultiviewCreateInfo { using NativeType = VkRenderPassMultiviewCreateInfo; @@ -82225,30 +77135,51 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRenderPassMultiviewCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRenderPassMultiviewCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRenderPassMultiviewCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkRenderPassMultiviewCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + subpassCount, + pViewMasks, + dependencyCount, + pViewOffsets, + correlationMaskCount, + pCorrelationMasks ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassMultiviewCreateInfo const & ) const = default; #else bool operator==( RenderPassMultiviewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassCount == rhs.subpassCount ) && - ( pViewMasks == rhs.pViewMasks ) && ( dependencyCount == rhs.dependencyCount ) && - ( pViewOffsets == rhs.pViewOffsets ) && ( correlationMaskCount == rhs.correlationMaskCount ) && - ( pCorrelationMasks == rhs.pCorrelationMasks ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderPassMultiviewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -82278,29 +77209,6 @@ namespace VULKAN_HPP_NAMESPACE }; using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo const & renderPassMultiviewCreateInfo ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassMultiviewCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassMultiviewCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassMultiviewCreateInfo.subpassCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, renderPassMultiviewCreateInfo.pViewMasks ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassMultiviewCreateInfo.dependencyCount ); - VULKAN_HPP_HASH_COMBINE( const int32_t *, seed, renderPassMultiviewCreateInfo.pViewOffsets ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassMultiviewCreateInfo.correlationMaskCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, renderPassMultiviewCreateInfo.pCorrelationMasks ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SubpassSampleLocationsEXT { using NativeType = VkSubpassSampleLocationsEXT; @@ -82344,27 +77252,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSubpassSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSubpassSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSubpassSampleLocationsEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkSubpassSampleLocationsEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( subpassIndex, sampleLocationsInfo ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassSampleLocationsEXT const & ) const = default; #else bool operator==( SubpassSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( subpassIndex == rhs.subpassIndex ) && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubpassSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -82380,24 +77298,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SubpassSampleLocationsEXT is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT const & subpassSampleLocationsEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassSampleLocationsEXT.subpassIndex ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT, seed, subpassSampleLocationsEXT.sampleLocationsInfo ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct RenderPassSampleLocationsBeginInfoEXT { using NativeType = VkRenderPassSampleLocationsBeginInfoEXT; @@ -82509,31 +77409,47 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRenderPassSampleLocationsBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRenderPassSampleLocationsBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRenderPassSampleLocationsBeginInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkRenderPassSampleLocationsBeginInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + attachmentInitialSampleLocationsCount, + pAttachmentInitialSampleLocations, + postSubpassSampleLocationsCount, + pPostSubpassSampleLocations ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassSampleLocationsBeginInfoEXT const & ) const = default; #else bool operator==( RenderPassSampleLocationsBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( attachmentInitialSampleLocationsCount == rhs.attachmentInitialSampleLocationsCount ) && - ( pAttachmentInitialSampleLocations == rhs.pAttachmentInitialSampleLocations ) && - ( postSubpassSampleLocationsCount == rhs.postSubpassSampleLocationsCount ) && - ( pPostSubpassSampleLocations == rhs.pPostSubpassSampleLocations ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderPassSampleLocationsBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -82560,32 +77476,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = RenderPassSampleLocationsBeginInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT const & - renderPassSampleLocationsBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassSampleLocationsBeginInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, renderPassSampleLocationsBeginInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, renderPassSampleLocationsBeginInfoEXT.attachmentInitialSampleLocationsCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT *, - seed, - renderPassSampleLocationsBeginInfoEXT.pAttachmentInitialSampleLocations ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderPassSampleLocationsBeginInfoEXT.postSubpassSampleLocationsCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT *, - seed, - renderPassSampleLocationsBeginInfoEXT.pPostSubpassSampleLocations ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct RenderPassTransformBeginInfoQCOM { using NativeType = VkRenderPassTransformBeginInfoQCOM; @@ -82631,27 +77521,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRenderPassTransformBeginInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRenderPassTransformBeginInfoQCOM const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRenderPassTransformBeginInfoQCOM &() VULKAN_HPP_NOEXCEPT + explicit operator VkRenderPassTransformBeginInfoQCOM &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, transform ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassTransformBeginInfoQCOM const & ) const = default; #else bool operator==( RenderPassTransformBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderPassTransformBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -82676,26 +77578,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = RenderPassTransformBeginInfoQCOM; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM const & renderPassTransformBeginInfoQCOM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderPassTransformBeginInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, renderPassTransformBeginInfoQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, renderPassTransformBeginInfoQCOM.transform ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct RenderingAttachmentInfoKHR { using NativeType = VkRenderingAttachmentInfoKHR; @@ -82803,16 +77685,44 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRenderingAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRenderingAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRenderingAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkRenderingAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + imageView, + imageLayout, + resolveMode, + resolveImageView, + resolveImageLayout, + loadOp, + storeOp, + clearValue ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderingAttachmentInfoKHR; const void * pNext = {}; @@ -82899,28 +77809,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRenderingFragmentDensityMapAttachmentInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRenderingFragmentDensityMapAttachmentInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRenderingFragmentDensityMapAttachmentInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkRenderingFragmentDensityMapAttachmentInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageView, imageLayout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderingFragmentDensityMapAttachmentInfoEXT const & ) const = default; #else bool operator==( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) && - ( imageLayout == rhs.imageLayout ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -82946,28 +77868,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = RenderingFragmentDensityMapAttachmentInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT const & - renderingFragmentDensityMapAttachmentInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, renderingFragmentDensityMapAttachmentInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, renderingFragmentDensityMapAttachmentInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ImageView, seed, renderingFragmentDensityMapAttachmentInfoEXT.imageView ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ImageLayout, seed, renderingFragmentDensityMapAttachmentInfoEXT.imageLayout ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct RenderingFragmentShadingRateAttachmentInfoKHR { using NativeType = VkRenderingFragmentShadingRateAttachmentInfoKHR; @@ -83036,29 +77936,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRenderingFragmentShadingRateAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRenderingFragmentShadingRateAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRenderingFragmentShadingRateAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkRenderingFragmentShadingRateAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageView, imageLayout, shadingRateAttachmentTexelSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderingFragmentShadingRateAttachmentInfoKHR const & ) const = default; #else bool operator==( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) && - ( imageLayout == rhs.imageLayout ) && - ( shadingRateAttachmentTexelSize == rhs.shadingRateAttachmentTexelSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -83085,31 +77997,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = RenderingFragmentShadingRateAttachmentInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR const & - renderingFragmentShadingRateAttachmentInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, renderingFragmentShadingRateAttachmentInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, renderingFragmentShadingRateAttachmentInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ImageView, seed, renderingFragmentShadingRateAttachmentInfoKHR.imageView ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ImageLayout, seed, renderingFragmentShadingRateAttachmentInfoKHR.imageLayout ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, - seed, - renderingFragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct RenderingInfoKHR { using NativeType = VkRenderingInfoKHR; @@ -83246,30 +78133,55 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkRenderingInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkRenderingInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkRenderingInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkRenderingInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + renderArea, + layerCount, + viewMask, + colorAttachmentCount, + pColorAttachments, + pDepthAttachment, + pStencilAttachment ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderingInfoKHR const & ) const = default; #else bool operator==( RenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( renderArea == rhs.renderArea ) && ( layerCount == rhs.layerCount ) && ( viewMask == rhs.viewMask ) && - ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachments == rhs.pColorAttachments ) && - ( pDepthAttachment == rhs.pDepthAttachment ) && ( pStencilAttachment == rhs.pStencilAttachment ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -83298,33 +78210,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = RenderingInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInfoKHR const & renderingInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, renderingInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, renderingInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::RenderingFlagsKHR, seed, renderingInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Rect2D, seed, renderingInfoKHR.renderArea ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderingInfoKHR.layerCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderingInfoKHR.viewMask ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, renderingInfoKHR.colorAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR *, seed, renderingInfoKHR.pColorAttachments ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR *, seed, renderingInfoKHR.pDepthAttachment ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR *, seed, renderingInfoKHR.pStencilAttachment ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ResolveImageInfo2KHR { using NativeType = VkResolveImageInfo2KHR; @@ -83439,30 +78324,44 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkResolveImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkResolveImageInfo2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkResolveImageInfo2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkResolveImageInfo2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ResolveImageInfo2KHR const & ) const = default; #else bool operator==( ResolveImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && - ( srcImageLayout == rhs.srcImageLayout ) && ( dstImage == rhs.dstImage ) && - ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && - ( pRegions == rhs.pRegions ); + return this->reflect() == rhs.reflect(); } bool operator!=( ResolveImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -83489,29 +78388,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ResolveImageInfo2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR const & resolveImageInfo2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, resolveImageInfo2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, resolveImageInfo2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, resolveImageInfo2KHR.srcImage ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, resolveImageInfo2KHR.srcImageLayout ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Image, seed, resolveImageInfo2KHR.dstImage ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageLayout, seed, resolveImageInfo2KHR.dstImageLayout ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, resolveImageInfo2KHR.regionCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ImageResolve2KHR *, seed, resolveImageInfo2KHR.pRegions ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SamplerBorderColorComponentMappingCreateInfoEXT { using NativeType = VkSamplerBorderColorComponentMappingCreateInfoEXT; @@ -83571,28 +78447,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSamplerBorderColorComponentMappingCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSamplerBorderColorComponentMappingCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSamplerBorderColorComponentMappingCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkSamplerBorderColorComponentMappingCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, components, srgb ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SamplerBorderColorComponentMappingCreateInfoEXT const & ) const = default; #else bool operator==( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( components == rhs.components ) && - ( srgb == rhs.srgb ); + return this->reflect() == rhs.reflect(); } bool operator!=( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -83618,27 +78506,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = SamplerBorderColorComponentMappingCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT const & - samplerBorderColorComponentMappingCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, samplerBorderColorComponentMappingCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerBorderColorComponentMappingCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ComponentMapping, seed, samplerBorderColorComponentMappingCreateInfoEXT.components ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, samplerBorderColorComponentMappingCreateInfoEXT.srgb ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SamplerCreateInfo { using NativeType = VkSamplerCreateInfo; @@ -83813,34 +78680,71 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSamplerCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSamplerCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSamplerCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkSamplerCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + magFilter, + minFilter, + mipmapMode, + addressModeU, + addressModeV, + addressModeW, + mipLodBias, + anisotropyEnable, + maxAnisotropy, + compareEnable, + compareOp, + minLod, + maxLod, + borderColor, + unnormalizedCoordinates ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SamplerCreateInfo const & ) const = default; #else bool operator==( SamplerCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( magFilter == rhs.magFilter ) && ( minFilter == rhs.minFilter ) && ( mipmapMode == rhs.mipmapMode ) && - ( addressModeU == rhs.addressModeU ) && ( addressModeV == rhs.addressModeV ) && - ( addressModeW == rhs.addressModeW ) && ( mipLodBias == rhs.mipLodBias ) && - ( anisotropyEnable == rhs.anisotropyEnable ) && ( maxAnisotropy == rhs.maxAnisotropy ) && - ( compareEnable == rhs.compareEnable ) && ( compareOp == rhs.compareOp ) && ( minLod == rhs.minLod ) && - ( maxLod == rhs.maxLod ) && ( borderColor == rhs.borderColor ) && - ( unnormalizedCoordinates == rhs.unnormalizedCoordinates ); + return this->reflect() == rhs.reflect(); } bool operator!=( SamplerCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -83877,38 +78781,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = SamplerCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & samplerCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, samplerCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerCreateFlags, seed, samplerCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Filter, seed, samplerCreateInfo.magFilter ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Filter, seed, samplerCreateInfo.minFilter ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerMipmapMode, seed, samplerCreateInfo.mipmapMode ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerAddressMode, seed, samplerCreateInfo.addressModeU ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerAddressMode, seed, samplerCreateInfo.addressModeV ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SamplerAddressMode, seed, samplerCreateInfo.addressModeW ); - VULKAN_HPP_HASH_COMBINE( float, seed, samplerCreateInfo.mipLodBias ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, samplerCreateInfo.anisotropyEnable ); - VULKAN_HPP_HASH_COMBINE( float, seed, samplerCreateInfo.maxAnisotropy ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, samplerCreateInfo.compareEnable ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::CompareOp, seed, samplerCreateInfo.compareOp ); - VULKAN_HPP_HASH_COMBINE( float, seed, samplerCreateInfo.minLod ); - VULKAN_HPP_HASH_COMBINE( float, seed, samplerCreateInfo.maxLod ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::BorderColor, seed, samplerCreateInfo.borderColor ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, samplerCreateInfo.unnormalizedCoordinates ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SamplerCustomBorderColorCreateInfoEXT { using NativeType = VkSamplerCustomBorderColorCreateInfoEXT; @@ -83966,16 +78838,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSamplerCustomBorderColorCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSamplerCustomBorderColorCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSamplerCustomBorderColorCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkSamplerCustomBorderColorCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, customBorderColor, format ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSamplerCustomBorderColorCreateInfoEXT; const void * pNext = {}; @@ -84043,27 +78928,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSamplerReductionModeCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSamplerReductionModeCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSamplerReductionModeCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkSamplerReductionModeCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, reductionMode ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SamplerReductionModeCreateInfo const & ) const = default; #else bool operator==( SamplerReductionModeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( reductionMode == rhs.reductionMode ); + return this->reflect() == rhs.reflect(); } bool operator!=( SamplerReductionModeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -84089,25 +78986,6 @@ namespace VULKAN_HPP_NAMESPACE }; using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo const & samplerReductionModeCreateInfo ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, samplerReductionModeCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerReductionModeCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SamplerReductionMode, seed, samplerReductionModeCreateInfo.reductionMode ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SamplerYcbcrConversionCreateInfo { using NativeType = VkSamplerYcbcrConversionCreateInfo; @@ -84217,30 +79095,55 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSamplerYcbcrConversionCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSamplerYcbcrConversionCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSamplerYcbcrConversionCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkSamplerYcbcrConversionCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + format, + ycbcrModel, + ycbcrRange, + components, + xChromaOffset, + yChromaOffset, + chromaFilter, + forceExplicitReconstruction ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SamplerYcbcrConversionCreateInfo const & ) const = default; #else bool operator==( SamplerYcbcrConversionCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && - ( ycbcrModel == rhs.ycbcrModel ) && ( ycbcrRange == rhs.ycbcrRange ) && ( components == rhs.components ) && - ( xChromaOffset == rhs.xChromaOffset ) && ( yChromaOffset == rhs.yChromaOffset ) && - ( chromaFilter == rhs.chromaFilter ) && ( forceExplicitReconstruction == rhs.forceExplicitReconstruction ); + return this->reflect() == rhs.reflect(); } bool operator!=( SamplerYcbcrConversionCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -84273,38 +79176,6 @@ namespace VULKAN_HPP_NAMESPACE }; using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & samplerYcbcrConversionCreateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, samplerYcbcrConversionCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerYcbcrConversionCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, samplerYcbcrConversionCreateInfo.format ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion, seed, samplerYcbcrConversionCreateInfo.ycbcrModel ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SamplerYcbcrRange, seed, samplerYcbcrConversionCreateInfo.ycbcrRange ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ComponentMapping, seed, samplerYcbcrConversionCreateInfo.components ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ChromaLocation, seed, samplerYcbcrConversionCreateInfo.xChromaOffset ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ChromaLocation, seed, samplerYcbcrConversionCreateInfo.yChromaOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Filter, seed, samplerYcbcrConversionCreateInfo.chromaFilter ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, samplerYcbcrConversionCreateInfo.forceExplicitReconstruction ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SamplerYcbcrConversionImageFormatProperties { using NativeType = VkSamplerYcbcrConversionImageFormatProperties; @@ -84339,28 +79210,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkSamplerYcbcrConversionImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSamplerYcbcrConversionImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSamplerYcbcrConversionImageFormatProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkSamplerYcbcrConversionImageFormatProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, combinedImageSamplerDescriptorCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SamplerYcbcrConversionImageFormatProperties const & ) const = default; #else bool operator==( SamplerYcbcrConversionImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( combinedImageSamplerDescriptorCount == rhs.combinedImageSamplerDescriptorCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( SamplerYcbcrConversionImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -84386,26 +79266,6 @@ namespace VULKAN_HPP_NAMESPACE }; using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties const & - samplerYcbcrConversionImageFormatProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, samplerYcbcrConversionImageFormatProperties.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, samplerYcbcrConversionImageFormatProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( - uint32_t, seed, samplerYcbcrConversionImageFormatProperties.combinedImageSamplerDescriptorCount ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SamplerYcbcrConversionInfo { using NativeType = VkSamplerYcbcrConversionInfo; @@ -84450,27 +79310,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSamplerYcbcrConversionInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSamplerYcbcrConversionInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSamplerYcbcrConversionInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkSamplerYcbcrConversionInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, conversion ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SamplerYcbcrConversionInfo const & ) const = default; #else bool operator==( SamplerYcbcrConversionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conversion == rhs.conversion ); + return this->reflect() == rhs.reflect(); } bool operator!=( SamplerYcbcrConversionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -84494,25 +79366,6 @@ namespace VULKAN_HPP_NAMESPACE }; using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo const & samplerYcbcrConversionInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, samplerYcbcrConversionInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, samplerYcbcrConversionInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, seed, samplerYcbcrConversionInfo.conversion ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_SCREEN_QNX ) struct ScreenSurfaceCreateInfoQNX { @@ -84575,28 +79428,41 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkScreenSurfaceCreateInfoQNX const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkScreenSurfaceCreateInfoQNX const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkScreenSurfaceCreateInfoQNX &() VULKAN_HPP_NOEXCEPT + explicit operator VkScreenSurfaceCreateInfoQNX &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, context, window ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ScreenSurfaceCreateInfoQNX const & ) const = default; # else bool operator==( ScreenSurfaceCreateInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( context == rhs.context ) && - ( window == rhs.window ); + return this->reflect() == rhs.reflect(); } bool operator!=( ScreenSurfaceCreateInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -84620,28 +79486,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = ScreenSurfaceCreateInfoQNX; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & screenSurfaceCreateInfoQNX ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, screenSurfaceCreateInfoQNX.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, screenSurfaceCreateInfoQNX.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagsQNX, seed, screenSurfaceCreateInfoQNX.flags ); - VULKAN_HPP_HASH_COMBINE( struct _screen_context *, seed, screenSurfaceCreateInfoQNX.context ); - VULKAN_HPP_HASH_COMBINE( struct _screen_window *, seed, screenSurfaceCreateInfoQNX.window ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ struct SemaphoreCreateInfo @@ -84687,27 +79531,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSemaphoreCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSemaphoreCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSemaphoreCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkSemaphoreCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreCreateInfo const & ) const = default; #else bool operator==( SemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( SemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -84729,24 +79585,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = SemaphoreCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & semaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SemaphoreCreateFlags, seed, semaphoreCreateInfo.flags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SemaphoreGetFdInfoKHR { using NativeType = VkSemaphoreGetFdInfoKHR; @@ -84800,28 +79638,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSemaphoreGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSemaphoreGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSemaphoreGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkSemaphoreGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, handleType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreGetFdInfoKHR const & ) const = default; #else bool operator==( SemaphoreGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( SemaphoreGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -84845,26 +79695,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = SemaphoreGetFdInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR const & semaphoreGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreGetFdInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreGetFdInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreGetFdInfoKHR.semaphore ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, semaphoreGetFdInfoKHR.handleType ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_WIN32_KHR ) struct SemaphoreGetWin32HandleInfoKHR { @@ -84921,28 +79751,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSemaphoreGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSemaphoreGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSemaphoreGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkSemaphoreGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, handleType ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreGetWin32HandleInfoKHR const & ) const = default; # else bool operator==( SemaphoreGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( SemaphoreGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -84967,27 +79809,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = SemaphoreGetWin32HandleInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR const & semaphoreGetWin32HandleInfoKHR ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreGetWin32HandleInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreGetWin32HandleInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreGetWin32HandleInfoKHR.semaphore ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, semaphoreGetWin32HandleInfoKHR.handleType ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #if defined( VK_USE_PLATFORM_FUCHSIA ) @@ -85048,28 +79869,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSemaphoreGetZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSemaphoreGetZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSemaphoreGetZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + explicit operator VkSemaphoreGetZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, handleType ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreGetZirconHandleInfoFUCHSIA const & ) const = default; # else bool operator==( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -85094,27 +79927,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = SemaphoreGetZirconHandleInfoFUCHSIA; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA const & - semaphoreGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreGetZirconHandleInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreGetZirconHandleInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreGetZirconHandleInfoFUCHSIA.semaphore ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits, seed, semaphoreGetZirconHandleInfoFUCHSIA.handleType ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_FUCHSIA*/ struct SemaphoreSignalInfo @@ -85167,28 +79979,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSemaphoreSignalInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSemaphoreSignalInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSemaphoreSignalInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkSemaphoreSignalInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, value ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreSignalInfo const & ) const = default; #else bool operator==( SemaphoreSignalInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && - ( value == rhs.value ); + return this->reflect() == rhs.reflect(); } bool operator!=( SemaphoreSignalInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -85212,25 +80036,6 @@ namespace VULKAN_HPP_NAMESPACE }; using SemaphoreSignalInfoKHR = SemaphoreSignalInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo const & semaphoreSignalInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreSignalInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreSignalInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreSignalInfo.semaphore ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, semaphoreSignalInfo.value ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SemaphoreSubmitInfoKHR { using NativeType = VkSemaphoreSubmitInfoKHR; @@ -85298,28 +80103,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSemaphoreSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSemaphoreSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSemaphoreSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkSemaphoreSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, value, stageMask, deviceIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreSubmitInfoKHR const & ) const = default; #else bool operator==( SemaphoreSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && - ( value == rhs.value ) && ( stageMask == rhs.stageMask ) && ( deviceIndex == rhs.deviceIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( SemaphoreSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -85345,27 +80164,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = SemaphoreSubmitInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR const & semaphoreSubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreSubmitInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreSubmitInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Semaphore, seed, semaphoreSubmitInfoKHR.semaphore ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, semaphoreSubmitInfoKHR.value ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR, seed, semaphoreSubmitInfoKHR.stageMask ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, semaphoreSubmitInfoKHR.deviceIndex ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SemaphoreTypeCreateInfo { using NativeType = VkSemaphoreTypeCreateInfo; @@ -85417,28 +80215,40 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSemaphoreTypeCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSemaphoreTypeCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSemaphoreTypeCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkSemaphoreTypeCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphoreType, initialValue ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreTypeCreateInfo const & ) const = default; #else bool operator==( SemaphoreTypeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphoreType == rhs.semaphoreType ) && - ( initialValue == rhs.initialValue ); + return this->reflect() == rhs.reflect(); } bool operator!=( SemaphoreTypeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -85463,25 +80273,6 @@ namespace VULKAN_HPP_NAMESPACE }; using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo const & semaphoreTypeCreateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreTypeCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreTypeCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SemaphoreType, seed, semaphoreTypeCreateInfo.semaphoreType ); - VULKAN_HPP_HASH_COMBINE( uint64_t, seed, semaphoreTypeCreateInfo.initialValue ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SemaphoreWaitInfo { using NativeType = VkSemaphoreWaitInfo; @@ -85592,29 +80383,42 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSemaphoreWaitInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSemaphoreWaitInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSemaphoreWaitInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkSemaphoreWaitInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, semaphoreCount, pSemaphores, pValues ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreWaitInfo const & ) const = default; #else bool operator==( SemaphoreWaitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( semaphoreCount == rhs.semaphoreCount ) && ( pSemaphores == rhs.pSemaphores ) && - ( pValues == rhs.pValues ); + return this->reflect() == rhs.reflect(); } bool operator!=( SemaphoreWaitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -85640,26 +80444,6 @@ namespace VULKAN_HPP_NAMESPACE }; using SemaphoreWaitInfoKHR = SemaphoreWaitInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo const & semaphoreWaitInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, semaphoreWaitInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, semaphoreWaitInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SemaphoreWaitFlags, seed, semaphoreWaitInfo.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, semaphoreWaitInfo.semaphoreCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, semaphoreWaitInfo.pSemaphores ); - VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, semaphoreWaitInfo.pValues ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SetStateFlagsIndirectCommandNV { using NativeType = VkSetStateFlagsIndirectCommandNV; @@ -85692,27 +80476,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSetStateFlagsIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSetStateFlagsIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSetStateFlagsIndirectCommandNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkSetStateFlagsIndirectCommandNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( data ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SetStateFlagsIndirectCommandNV const & ) const = default; #else bool operator==( SetStateFlagsIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( data == rhs.data ); + return this->reflect() == rhs.reflect(); } bool operator!=( SetStateFlagsIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -85728,22 +80522,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "SetStateFlagsIndirectCommandNV is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV const & setStateFlagsIndirectCommandNV ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, setStateFlagsIndirectCommandNV.data ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ShaderModuleCreateInfo { using NativeType = VkShaderModuleCreateInfo; @@ -85819,28 +80597,41 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkShaderModuleCreateInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkShaderModuleCreateInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkShaderModuleCreateInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkShaderModuleCreateInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, codeSize, pCode ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ShaderModuleCreateInfo const & ) const = default; #else bool operator==( ShaderModuleCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( codeSize == rhs.codeSize ) && ( pCode == rhs.pCode ); + return this->reflect() == rhs.reflect(); } bool operator!=( ShaderModuleCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -85865,26 +80656,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ShaderModuleCreateInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & shaderModuleCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, shaderModuleCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, shaderModuleCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderModuleCreateFlags, seed, shaderModuleCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( size_t, seed, shaderModuleCreateInfo.codeSize ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, shaderModuleCreateInfo.pCode ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ShaderModuleValidationCacheCreateInfoEXT { using NativeType = VkShaderModuleValidationCacheCreateInfoEXT; @@ -85935,27 +80706,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkShaderModuleValidationCacheCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkShaderModuleValidationCacheCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkShaderModuleValidationCacheCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkShaderModuleValidationCacheCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, validationCache ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ShaderModuleValidationCacheCreateInfoEXT const & ) const = default; #else bool operator==( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( validationCache == rhs.validationCache ); + return this->reflect() == rhs.reflect(); } bool operator!=( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -85980,26 +80763,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ShaderModuleValidationCacheCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT const & - shaderModuleValidationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, shaderModuleValidationCacheCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, shaderModuleValidationCacheCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ValidationCacheEXT, seed, shaderModuleValidationCacheCreateInfoEXT.validationCache ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ShaderResourceUsageAMD { using NativeType = VkShaderResourceUsageAMD; @@ -86032,30 +80795,38 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkShaderResourceUsageAMD const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkShaderResourceUsageAMD const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkShaderResourceUsageAMD &() VULKAN_HPP_NOEXCEPT + explicit operator VkShaderResourceUsageAMD &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + numUsedVgprs, numUsedSgprs, ldsSizePerLocalWorkGroup, ldsUsageSizeInBytes, scratchMemUsageInBytes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ShaderResourceUsageAMD const & ) const = default; #else bool operator==( ShaderResourceUsageAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( numUsedVgprs == rhs.numUsedVgprs ) && ( numUsedSgprs == rhs.numUsedSgprs ) && - ( ldsSizePerLocalWorkGroup == rhs.ldsSizePerLocalWorkGroup ) && - ( ldsUsageSizeInBytes == rhs.ldsUsageSizeInBytes ) && - ( scratchMemUsageInBytes == rhs.scratchMemUsageInBytes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ShaderResourceUsageAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -86074,26 +80845,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ShaderResourceUsageAMD is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD const & shaderResourceUsageAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderResourceUsageAMD.numUsedVgprs ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderResourceUsageAMD.numUsedSgprs ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderResourceUsageAMD.ldsSizePerLocalWorkGroup ); - VULKAN_HPP_HASH_COMBINE( size_t, seed, shaderResourceUsageAMD.ldsUsageSizeInBytes ); - VULKAN_HPP_HASH_COMBINE( size_t, seed, shaderResourceUsageAMD.scratchMemUsageInBytes ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ShaderStatisticsInfoAMD { using NativeType = VkShaderStatisticsInfoAMD; @@ -86132,30 +80883,49 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkShaderStatisticsInfoAMD const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkShaderStatisticsInfoAMD const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkShaderStatisticsInfoAMD &() VULKAN_HPP_NOEXCEPT + explicit operator VkShaderStatisticsInfoAMD &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( shaderStageMask, + resourceUsage, + numPhysicalVgprs, + numPhysicalSgprs, + numAvailableVgprs, + numAvailableSgprs, + computeWorkGroupSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ShaderStatisticsInfoAMD const & ) const = default; #else bool operator==( ShaderStatisticsInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( shaderStageMask == rhs.shaderStageMask ) && ( resourceUsage == rhs.resourceUsage ) && - ( numPhysicalVgprs == rhs.numPhysicalVgprs ) && ( numPhysicalSgprs == rhs.numPhysicalSgprs ) && - ( numAvailableVgprs == rhs.numAvailableVgprs ) && ( numAvailableSgprs == rhs.numAvailableSgprs ) && - ( computeWorkGroupSize == rhs.computeWorkGroupSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( ShaderStatisticsInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -86176,32 +80946,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ShaderStatisticsInfoAMD is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD const & shaderStatisticsInfoAMD ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ShaderStageFlags, seed, shaderStatisticsInfoAMD.shaderStageMask ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD, seed, shaderStatisticsInfoAMD.resourceUsage ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.numPhysicalVgprs ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.numPhysicalSgprs ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.numAvailableVgprs ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.numAvailableSgprs ); - for ( size_t i = 0; i < 3; ++i ) - { - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, shaderStatisticsInfoAMD.computeWorkGroupSize[i] ); - } - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SharedPresentSurfaceCapabilitiesKHR { using NativeType = VkSharedPresentSurfaceCapabilitiesKHR; @@ -86234,28 +80978,38 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkSharedPresentSurfaceCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSharedPresentSurfaceCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSharedPresentSurfaceCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkSharedPresentSurfaceCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std:: + tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, sharedPresentSupportedUsageFlags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SharedPresentSurfaceCapabilitiesKHR const & ) const = default; #else bool operator==( SharedPresentSurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags ); + return this->reflect() == rhs.reflect(); } bool operator!=( SharedPresentSurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -86279,26 +81033,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = SharedPresentSurfaceCapabilitiesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR const & - sharedPresentSurfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sharedPresentSurfaceCapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, sharedPresentSurfaceCapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, - seed, - sharedPresentSurfaceCapabilitiesKHR.sharedPresentSupportedUsageFlags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SparseImageFormatProperties { using NativeType = VkSparseImageFormatProperties; @@ -86329,27 +81063,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkSparseImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSparseImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSparseImageFormatProperties &() VULKAN_HPP_NOEXCEPT + explicit operator VkSparseImageFormatProperties &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( aspectMask, imageGranularity, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageFormatProperties const & ) const = default; #else bool operator==( SparseImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( aspectMask == rhs.aspectMask ) && ( imageGranularity == rhs.imageGranularity ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( SparseImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -86367,24 +81113,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "SparseImageFormatProperties is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const & sparseImageFormatProperties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageAspectFlags, seed, sparseImageFormatProperties.aspectMask ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent3D, seed, sparseImageFormatProperties.imageGranularity ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SparseImageFormatFlags, seed, sparseImageFormatProperties.flags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SparseImageFormatProperties2 { using NativeType = VkSparseImageFormatProperties2; @@ -86414,27 +81142,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkSparseImageFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSparseImageFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSparseImageFormatProperties2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkSparseImageFormatProperties2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, properties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageFormatProperties2 const & ) const = default; #else bool operator==( SparseImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties ); + return this->reflect() == rhs.reflect(); } bool operator!=( SparseImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -86459,25 +81199,6 @@ namespace VULKAN_HPP_NAMESPACE }; using SparseImageFormatProperties2KHR = SparseImageFormatProperties2; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( - VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 const & sparseImageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sparseImageFormatProperties2.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, sparseImageFormatProperties2.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, seed, sparseImageFormatProperties2.properties ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SparseImageMemoryRequirements { using NativeType = VkSparseImageMemoryRequirements; @@ -86513,29 +81234,42 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkSparseImageMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSparseImageMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSparseImageMemoryRequirements &() VULKAN_HPP_NOEXCEPT + explicit operator VkSparseImageMemoryRequirements &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + formatProperties, imageMipTailFirstLod, imageMipTailSize, imageMipTailOffset, imageMipTailStride ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageMemoryRequirements const & ) const = default; #else bool operator==( SparseImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( formatProperties == rhs.formatProperties ) && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod ) && - ( imageMipTailSize == rhs.imageMipTailSize ) && ( imageMipTailOffset == rhs.imageMipTailOffset ) && - ( imageMipTailStride == rhs.imageMipTailStride ); + return this->reflect() == rhs.reflect(); } bool operator!=( SparseImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -86555,27 +81289,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "SparseImageMemoryRequirements is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements const & sparseImageMemoryRequirements ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, seed, sparseImageMemoryRequirements.formatProperties ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, sparseImageMemoryRequirements.imageMipTailFirstLod ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseImageMemoryRequirements.imageMipTailSize ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseImageMemoryRequirements.imageMipTailOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, sparseImageMemoryRequirements.imageMipTailStride ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SparseImageMemoryRequirements2 { using NativeType = VkSparseImageMemoryRequirements2; @@ -86606,27 +81319,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkSparseImageMemoryRequirements2 const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSparseImageMemoryRequirements2 const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSparseImageMemoryRequirements2 &() VULKAN_HPP_NOEXCEPT + explicit operator VkSparseImageMemoryRequirements2 &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryRequirements ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageMemoryRequirements2 const & ) const = default; #else bool operator==( SparseImageMemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryRequirements == rhs.memoryRequirements ); + return this->reflect() == rhs.reflect(); } bool operator!=( SparseImageMemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -86651,25 +81376,6 @@ namespace VULKAN_HPP_NAMESPACE }; using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 const & sparseImageMemoryRequirements2 ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, sparseImageMemoryRequirements2.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, sparseImageMemoryRequirements2.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, seed, sparseImageMemoryRequirements2.memoryRequirements ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_GGP ) struct StreamDescriptorSurfaceCreateInfoGGP { @@ -86727,28 +81433,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkStreamDescriptorSurfaceCreateInfoGGP const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkStreamDescriptorSurfaceCreateInfoGGP const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkStreamDescriptorSurfaceCreateInfoGGP &() VULKAN_HPP_NOEXCEPT + explicit operator VkStreamDescriptorSurfaceCreateInfoGGP &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, streamDescriptor ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( StreamDescriptorSurfaceCreateInfoGGP const & ) const = default; # else bool operator==( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( memcmp( &streamDescriptor, &rhs.streamDescriptor, sizeof( GgpStreamDescriptor ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -86772,27 +81490,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = StreamDescriptorSurfaceCreateInfoGGP; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & - streamDescriptorSurfaceCreateInfoGGP ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, streamDescriptorSurfaceCreateInfoGGP.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, streamDescriptorSurfaceCreateInfoGGP.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateFlagsGGP, seed, streamDescriptorSurfaceCreateInfoGGP.flags ); - VULKAN_HPP_HASH_COMBINE( GgpStreamDescriptor, seed, streamDescriptorSurfaceCreateInfoGGP.streamDescriptor ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_GGP*/ struct StridedDeviceAddressRegionKHR @@ -86849,27 +81546,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkStridedDeviceAddressRegionKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkStridedDeviceAddressRegionKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkStridedDeviceAddressRegionKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkStridedDeviceAddressRegionKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( deviceAddress, stride, size ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( StridedDeviceAddressRegionKHR const & ) const = default; #else bool operator==( StridedDeviceAddressRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( deviceAddress == rhs.deviceAddress ) && ( stride == rhs.stride ) && ( size == rhs.size ); + return this->reflect() == rhs.reflect(); } bool operator!=( StridedDeviceAddressRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -86887,24 +81596,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "StridedDeviceAddressRegionKHR is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR const & stridedDeviceAddressRegionKHR ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceAddress, seed, stridedDeviceAddressRegionKHR.deviceAddress ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, stridedDeviceAddressRegionKHR.stride ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, stridedDeviceAddressRegionKHR.size ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SubmitInfo { using NativeType = VkSubmitInfo; @@ -87072,30 +81763,53 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSubmitInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSubmitInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSubmitInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkSubmitInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + waitSemaphoreCount, + pWaitSemaphores, + pWaitDstStageMask, + commandBufferCount, + pCommandBuffers, + signalSemaphoreCount, + pSignalSemaphores ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubmitInfo const & ) const = default; #else bool operator==( SubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) && - ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( pWaitDstStageMask == rhs.pWaitDstStageMask ) && - ( commandBufferCount == rhs.commandBufferCount ) && ( pCommandBuffers == rhs.pCommandBuffers ) && - ( signalSemaphoreCount == rhs.signalSemaphoreCount ) && ( pSignalSemaphores == rhs.pSignalSemaphores ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -87123,29 +81837,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = SubmitInfo; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo const & submitInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, submitInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, submitInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo.waitSemaphoreCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, submitInfo.pWaitSemaphores ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::PipelineStageFlags *, seed, submitInfo.pWaitDstStageMask ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo.commandBufferCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::CommandBuffer *, seed, submitInfo.pCommandBuffers ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo.signalSemaphoreCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::Semaphore *, seed, submitInfo.pSignalSemaphores ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SubmitInfo2KHR { using NativeType = VkSubmitInfo2KHR; @@ -87294,33 +81985,53 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSubmitInfo2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSubmitInfo2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSubmitInfo2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkSubmitInfo2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + waitSemaphoreInfoCount, + pWaitSemaphoreInfos, + commandBufferInfoCount, + pCommandBufferInfos, + signalSemaphoreInfoCount, + pSignalSemaphoreInfos ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubmitInfo2KHR const & ) const = default; #else bool operator==( SubmitInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( waitSemaphoreInfoCount == rhs.waitSemaphoreInfoCount ) && - ( pWaitSemaphoreInfos == rhs.pWaitSemaphoreInfos ) && - ( commandBufferInfoCount == rhs.commandBufferInfoCount ) && - ( pCommandBufferInfos == rhs.pCommandBufferInfos ) && - ( signalSemaphoreInfoCount == rhs.signalSemaphoreInfoCount ) && - ( pSignalSemaphoreInfos == rhs.pSignalSemaphoreInfos ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubmitInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -87348,32 +82059,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = SubmitInfo2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo2KHR const & submitInfo2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, submitInfo2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, submitInfo2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SubmitFlagsKHR, seed, submitInfo2KHR.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo2KHR.waitSemaphoreInfoCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR *, seed, submitInfo2KHR.pWaitSemaphoreInfos ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo2KHR.commandBufferInfoCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfoKHR *, seed, submitInfo2KHR.pCommandBufferInfos ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, submitInfo2KHR.signalSemaphoreInfoCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR *, seed, submitInfo2KHR.pSignalSemaphoreInfos ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SubpassBeginInfo { using NativeType = VkSubpassBeginInfo; @@ -87417,27 +82102,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSubpassBeginInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSubpassBeginInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSubpassBeginInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkSubpassBeginInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, contents ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassBeginInfo const & ) const = default; #else bool operator==( SubpassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( contents == rhs.contents ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubpassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -87460,23 +82157,6 @@ namespace VULKAN_HPP_NAMESPACE }; using SubpassBeginInfoKHR = SubpassBeginInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassBeginInfo const & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassBeginInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassBeginInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SubpassContents, seed, subpassBeginInfo.contents ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SubpassDescriptionDepthStencilResolve { using NativeType = VkSubpassDescriptionDepthStencilResolve; @@ -87543,29 +82223,41 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSubpassDescriptionDepthStencilResolve const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSubpassDescriptionDepthStencilResolve const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSubpassDescriptionDepthStencilResolve &() VULKAN_HPP_NOEXCEPT + explicit operator VkSubpassDescriptionDepthStencilResolve &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, depthResolveMode, stencilResolveMode, pDepthStencilResolveAttachment ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassDescriptionDepthStencilResolve const & ) const = default; #else bool operator==( SubpassDescriptionDepthStencilResolve const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthResolveMode == rhs.depthResolveMode ) && - ( stencilResolveMode == rhs.stencilResolveMode ) && - ( pDepthStencilResolveAttachment == rhs.pDepthStencilResolveAttachment ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubpassDescriptionDepthStencilResolve const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -87592,30 +82284,6 @@ namespace VULKAN_HPP_NAMESPACE }; using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve const & - subpassDescriptionDepthStencilResolve ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassDescriptionDepthStencilResolve.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassDescriptionDepthStencilResolve.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ResolveModeFlagBits, seed, subpassDescriptionDepthStencilResolve.depthResolveMode ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ResolveModeFlagBits, seed, subpassDescriptionDepthStencilResolve.stencilResolveMode ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AttachmentReference2 *, - seed, - subpassDescriptionDepthStencilResolve.pDepthStencilResolveAttachment ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SubpassEndInfo { using NativeType = VkSubpassEndInfo; @@ -87649,27 +82317,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSubpassEndInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSubpassEndInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSubpassEndInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkSubpassEndInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassEndInfo const & ) const = default; #else bool operator==( SubpassEndInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubpassEndInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -87691,22 +82369,144 @@ namespace VULKAN_HPP_NAMESPACE }; using SubpassEndInfoKHR = SubpassEndInfo; -} // namespace VULKAN_HPP_NAMESPACE + struct SubpassFragmentDensityMapOffsetEndInfoQCOM + { + using NativeType = VkSubpassFragmentDensityMapOffsetEndInfoQCOM; -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassEndInfo const & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = + StructureType::eSubpassFragmentDensityMapOffsetEndInfoQCOM; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SubpassFragmentDensityMapOffsetEndInfoQCOM( + uint32_t fragmentDensityOffsetCount_ = {}, + const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets_ = {} ) VULKAN_HPP_NOEXCEPT + : fragmentDensityOffsetCount( fragmentDensityOffsetCount_ ) + , pFragmentDensityOffsets( pFragmentDensityOffsets_ ) + {} + + VULKAN_HPP_CONSTEXPR SubpassFragmentDensityMapOffsetEndInfoQCOM( + SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SubpassFragmentDensityMapOffsetEndInfoQCOM( VkSubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) + VULKAN_HPP_NOEXCEPT + : SubpassFragmentDensityMapOffsetEndInfoQCOM( + *reinterpret_cast( &rhs ) ) + {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubpassFragmentDensityMapOffsetEndInfoQCOM( + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & + fragmentDensityOffsets_ ) + : fragmentDensityOffsetCount( static_cast( fragmentDensityOffsets_.size() ) ) + , pFragmentDensityOffsets( fragmentDensityOffsets_.data() ) + {} +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + SubpassFragmentDensityMapOffsetEndInfoQCOM & + operator=( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SubpassFragmentDensityMapOffsetEndInfoQCOM & + operator=( VkSubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SubpassFragmentDensityMapOffsetEndInfoQCOM & + setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassFragmentDensityMapOffsetEndInfoQCOM & + setFragmentDensityOffsetCount( uint32_t fragmentDensityOffsetCount_ ) VULKAN_HPP_NOEXCEPT + { + fragmentDensityOffsetCount = fragmentDensityOffsetCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassFragmentDensityMapOffsetEndInfoQCOM & + setPFragmentDensityOffsets( const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets_ ) VULKAN_HPP_NOEXCEPT + { + pFragmentDensityOffsets = pFragmentDensityOffsets_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubpassFragmentDensityMapOffsetEndInfoQCOM & setFragmentDensityOffsets( + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & + fragmentDensityOffsets_ ) VULKAN_HPP_NOEXCEPT + { + fragmentDensityOffsetCount = static_cast( fragmentDensityOffsets_.size() ); + pFragmentDensityOffsets = fragmentDensityOffsets_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + explicit operator VkSubpassFragmentDensityMapOffsetEndInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + explicit operator VkSubpassFragmentDensityMapOffsetEndInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentDensityOffsetCount, pFragmentDensityOffsets ); + } + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SubpassFragmentDensityMapOffsetEndInfoQCOM const & ) const = default; +#else + bool operator==( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return this->reflect() == rhs.reflect(); + } + + bool operator!=( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return this->reflect() != rhs.reflect(); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSubpassFragmentDensityMapOffsetEndInfoQCOM; + const void * pNext = {}; + uint32_t fragmentDensityOffsetCount = {}; + const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets = {}; + }; + VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM ) == + sizeof( VkSubpassFragmentDensityMapOffsetEndInfoQCOM ), + "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, + "SubpassFragmentDensityMapOffsetEndInfoQCOM is not nothrow_move_constructible!" ); + + template <> + struct CppType { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassEndInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, subpassEndInfo.pNext ); - return seed; - } -}; + using Type = SubpassFragmentDensityMapOffsetEndInfoQCOM; + }; -namespace VULKAN_HPP_NAMESPACE -{ struct SubpassShadingPipelineCreateInfoHUAWEI { using NativeType = VkSubpassShadingPipelineCreateInfoHUAWEI; @@ -87741,28 +82541,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkSubpassShadingPipelineCreateInfoHUAWEI const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSubpassShadingPipelineCreateInfoHUAWEI const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSubpassShadingPipelineCreateInfoHUAWEI &() VULKAN_HPP_NOEXCEPT + explicit operator VkSubpassShadingPipelineCreateInfoHUAWEI &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, renderPass, subpass ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassShadingPipelineCreateInfoHUAWEI const & ) const = default; #else bool operator==( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) && - ( subpass == rhs.subpass ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -87788,26 +82600,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = SubpassShadingPipelineCreateInfoHUAWEI; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI const & - subpassShadingPipelineCreateInfoHUAWEI ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, subpassShadingPipelineCreateInfoHUAWEI.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, subpassShadingPipelineCreateInfoHUAWEI.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::RenderPass, seed, subpassShadingPipelineCreateInfoHUAWEI.renderPass ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, subpassShadingPipelineCreateInfoHUAWEI.subpass ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SurfaceCapabilities2EXT { using NativeType = VkSurfaceCapabilities2EXT; @@ -87857,34 +82649,61 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkSurfaceCapabilities2EXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSurfaceCapabilities2EXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSurfaceCapabilities2EXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkSurfaceCapabilities2EXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + minImageCount, + maxImageCount, + currentExtent, + minImageExtent, + maxImageExtent, + maxImageArrayLayers, + supportedTransforms, + currentTransform, + supportedCompositeAlpha, + supportedUsageFlags, + supportedSurfaceCounters ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceCapabilities2EXT const & ) const = default; #else bool operator==( SurfaceCapabilities2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minImageCount == rhs.minImageCount ) && - ( maxImageCount == rhs.maxImageCount ) && ( currentExtent == rhs.currentExtent ) && - ( minImageExtent == rhs.minImageExtent ) && ( maxImageExtent == rhs.maxImageExtent ) && - ( maxImageArrayLayers == rhs.maxImageArrayLayers ) && ( supportedTransforms == rhs.supportedTransforms ) && - ( currentTransform == rhs.currentTransform ) && - ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) && - ( supportedUsageFlags == rhs.supportedUsageFlags ) && - ( supportedSurfaceCounters == rhs.supportedSurfaceCounters ); + return this->reflect() == rhs.reflect(); } bool operator!=( SurfaceCapabilities2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -87918,38 +82737,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = SurfaceCapabilities2EXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT const & surfaceCapabilities2EXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceCapabilities2EXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceCapabilities2EXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilities2EXT.minImageCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilities2EXT.maxImageCount ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilities2EXT.currentExtent ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilities2EXT.minImageExtent ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilities2EXT.maxImageExtent ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilities2EXT.maxImageArrayLayers ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR, seed, surfaceCapabilities2EXT.supportedTransforms ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, surfaceCapabilities2EXT.currentTransform ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR, seed, surfaceCapabilities2EXT.supportedCompositeAlpha ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, surfaceCapabilities2EXT.supportedUsageFlags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT, seed, surfaceCapabilities2EXT.supportedSurfaceCounters ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SurfaceCapabilitiesKHR { using NativeType = VkSurfaceCapabilitiesKHR; @@ -87994,32 +82781,55 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkSurfaceCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSurfaceCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSurfaceCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkSurfaceCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( minImageCount, + maxImageCount, + currentExtent, + minImageExtent, + maxImageExtent, + maxImageArrayLayers, + supportedTransforms, + currentTransform, + supportedCompositeAlpha, + supportedUsageFlags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceCapabilitiesKHR const & ) const = default; #else bool operator==( SurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( minImageCount == rhs.minImageCount ) && ( maxImageCount == rhs.maxImageCount ) && - ( currentExtent == rhs.currentExtent ) && ( minImageExtent == rhs.minImageExtent ) && - ( maxImageExtent == rhs.maxImageExtent ) && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) && - ( supportedTransforms == rhs.supportedTransforms ) && ( currentTransform == rhs.currentTransform ) && - ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) && - ( supportedUsageFlags == rhs.supportedUsageFlags ); + return this->reflect() == rhs.reflect(); } bool operator!=( SurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -88044,34 +82854,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SurfaceCapabilitiesKHR is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR const & surfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilitiesKHR.minImageCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilitiesKHR.maxImageCount ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilitiesKHR.currentExtent ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilitiesKHR.minImageExtent ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, surfaceCapabilitiesKHR.maxImageExtent ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, surfaceCapabilitiesKHR.maxImageArrayLayers ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR, seed, surfaceCapabilitiesKHR.supportedTransforms ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, surfaceCapabilitiesKHR.currentTransform ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR, seed, surfaceCapabilitiesKHR.supportedCompositeAlpha ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, surfaceCapabilitiesKHR.supportedUsageFlags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SurfaceCapabilities2KHR { using NativeType = VkSurfaceCapabilities2KHR; @@ -88100,27 +82882,39 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkSurfaceCapabilities2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSurfaceCapabilities2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSurfaceCapabilities2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkSurfaceCapabilities2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, surfaceCapabilities ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceCapabilities2KHR const & ) const = default; #else bool operator==( SurfaceCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceCapabilities == rhs.surfaceCapabilities ); + return this->reflect() == rhs.reflect(); } bool operator!=( SurfaceCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -88143,25 +82937,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = SurfaceCapabilities2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR const & surfaceCapabilities2KHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceCapabilities2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceCapabilities2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR, seed, surfaceCapabilities2KHR.surfaceCapabilities ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_WIN32_KHR ) struct SurfaceCapabilitiesFullScreenExclusiveEXT { @@ -88212,28 +82987,37 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSurfaceCapabilitiesFullScreenExclusiveEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSurfaceCapabilitiesFullScreenExclusiveEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSurfaceCapabilitiesFullScreenExclusiveEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkSurfaceCapabilitiesFullScreenExclusiveEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fullScreenExclusiveSupported ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceCapabilitiesFullScreenExclusiveEXT const & ) const = default; # else bool operator==( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( fullScreenExclusiveSupported == rhs.fullScreenExclusiveSupported ); + return this->reflect() == rhs.reflect(); } bool operator!=( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -88257,27 +83041,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = SurfaceCapabilitiesFullScreenExclusiveEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT const & - surfaceCapabilitiesFullScreenExclusiveEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceCapabilitiesFullScreenExclusiveEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceCapabilitiesFullScreenExclusiveEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, surfaceCapabilitiesFullScreenExclusiveEXT.fullScreenExclusiveSupported ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct SurfaceFormatKHR @@ -88308,27 +83071,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkSurfaceFormatKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSurfaceFormatKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSurfaceFormatKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkSurfaceFormatKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( format, colorSpace ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceFormatKHR const & ) const = default; #else bool operator==( SurfaceFormatKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( format == rhs.format ) && ( colorSpace == rhs.colorSpace ); + return this->reflect() == rhs.reflect(); } bool operator!=( SurfaceFormatKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -88343,22 +83116,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SurfaceFormatKHR is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR const & surfaceFormatKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, surfaceFormatKHR.format ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ColorSpaceKHR, seed, surfaceFormatKHR.colorSpace ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SurfaceFormat2KHR { using NativeType = VkSurfaceFormat2KHR; @@ -88387,27 +83144,38 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkSurfaceFormat2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSurfaceFormat2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSurfaceFormat2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkSurfaceFormat2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std:: + tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, surfaceFormat ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceFormat2KHR const & ) const = default; #else bool operator==( SurfaceFormat2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceFormat == rhs.surfaceFormat ); + return this->reflect() == rhs.reflect(); } bool operator!=( SurfaceFormat2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -88429,23 +83197,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = SurfaceFormat2KHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR const & surfaceFormat2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceFormat2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceFormat2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, seed, surfaceFormat2KHR.surfaceFormat ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_WIN32_KHR ) struct SurfaceFullScreenExclusiveInfoEXT { @@ -88494,27 +83245,39 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSurfaceFullScreenExclusiveInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSurfaceFullScreenExclusiveInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSurfaceFullScreenExclusiveInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkSurfaceFullScreenExclusiveInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fullScreenExclusive ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceFullScreenExclusiveInfoEXT const & ) const = default; # else bool operator==( SurfaceFullScreenExclusiveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fullScreenExclusive == rhs.fullScreenExclusive ); + return this->reflect() == rhs.reflect(); } bool operator!=( SurfaceFullScreenExclusiveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -88538,26 +83301,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = SurfaceFullScreenExclusiveInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT const & - surfaceFullScreenExclusiveInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceFullScreenExclusiveInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, surfaceFullScreenExclusiveInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT, seed, surfaceFullScreenExclusiveInfoEXT.fullScreenExclusive ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #if defined( VK_USE_PLATFORM_WIN32_KHR ) @@ -88608,27 +83351,37 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSurfaceFullScreenExclusiveWin32InfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSurfaceFullScreenExclusiveWin32InfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSurfaceFullScreenExclusiveWin32InfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkSurfaceFullScreenExclusiveWin32InfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, hmonitor ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceFullScreenExclusiveWin32InfoEXT const & ) const = default; # else bool operator==( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hmonitor == rhs.hmonitor ); + return this->reflect() == rhs.reflect(); } bool operator!=( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -88652,25 +83405,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = SurfaceFullScreenExclusiveWin32InfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT const & - surfaceFullScreenExclusiveWin32InfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceFullScreenExclusiveWin32InfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, surfaceFullScreenExclusiveWin32InfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( HMONITOR, seed, surfaceFullScreenExclusiveWin32InfoEXT.hmonitor ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct SurfaceProtectedCapabilitiesKHR @@ -88718,27 +83452,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSurfaceProtectedCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSurfaceProtectedCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSurfaceProtectedCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkSurfaceProtectedCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, supportsProtected ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceProtectedCapabilitiesKHR const & ) const = default; #else bool operator==( SurfaceProtectedCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportsProtected == rhs.supportsProtected ); + return this->reflect() == rhs.reflect(); } bool operator!=( SurfaceProtectedCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -88762,25 +83506,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = SurfaceProtectedCapabilitiesKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR const & surfaceProtectedCapabilitiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, surfaceProtectedCapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, surfaceProtectedCapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, surfaceProtectedCapabilitiesKHR.supportsProtected ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SwapchainCounterCreateInfoEXT { using NativeType = VkSwapchainCounterCreateInfoEXT; @@ -88826,27 +83551,39 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSwapchainCounterCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSwapchainCounterCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSwapchainCounterCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkSwapchainCounterCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, surfaceCounters ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SwapchainCounterCreateInfoEXT const & ) const = default; #else bool operator==( SwapchainCounterCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceCounters == rhs.surfaceCounters ); + return this->reflect() == rhs.reflect(); } bool operator!=( SwapchainCounterCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -88870,25 +83607,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = SwapchainCounterCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT const & swapchainCounterCreateInfoEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, swapchainCounterCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, swapchainCounterCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT, seed, swapchainCounterCreateInfoEXT.surfaceCounters ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SwapchainCreateInfoKHR { using NativeType = VkSwapchainCreateInfoKHR; @@ -89116,34 +83834,71 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + surface, + minImageCount, + imageFormat, + imageColorSpace, + imageExtent, + imageArrayLayers, + imageUsage, + imageSharingMode, + queueFamilyIndexCount, + pQueueFamilyIndices, + preTransform, + compositeAlpha, + presentMode, + clipped, + oldSwapchain ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SwapchainCreateInfoKHR const & ) const = default; #else bool operator==( SwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( surface == rhs.surface ) && - ( minImageCount == rhs.minImageCount ) && ( imageFormat == rhs.imageFormat ) && - ( imageColorSpace == rhs.imageColorSpace ) && ( imageExtent == rhs.imageExtent ) && - ( imageArrayLayers == rhs.imageArrayLayers ) && ( imageUsage == rhs.imageUsage ) && - ( imageSharingMode == rhs.imageSharingMode ) && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && - ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) && ( preTransform == rhs.preTransform ) && - ( compositeAlpha == rhs.compositeAlpha ) && ( presentMode == rhs.presentMode ) && - ( clipped == rhs.clipped ) && ( oldSwapchain == rhs.oldSwapchain ); + return this->reflect() == rhs.reflect(); } bool operator!=( SwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -89183,41 +83938,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = SwapchainCreateInfoKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & swapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, swapchainCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, swapchainCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainCreateFlagsKHR, seed, swapchainCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SurfaceKHR, seed, swapchainCreateInfoKHR.surface ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, swapchainCreateInfoKHR.minImageCount ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, swapchainCreateInfoKHR.imageFormat ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ColorSpaceKHR, seed, swapchainCreateInfoKHR.imageColorSpace ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, swapchainCreateInfoKHR.imageExtent ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, swapchainCreateInfoKHR.imageArrayLayers ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageUsageFlags, seed, swapchainCreateInfoKHR.imageUsage ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SharingMode, seed, swapchainCreateInfoKHR.imageSharingMode ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, swapchainCreateInfoKHR.queueFamilyIndexCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, swapchainCreateInfoKHR.pQueueFamilyIndices ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR, seed, swapchainCreateInfoKHR.preTransform ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::CompositeAlphaFlagBitsKHR, seed, swapchainCreateInfoKHR.compositeAlpha ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::PresentModeKHR, seed, swapchainCreateInfoKHR.presentMode ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, swapchainCreateInfoKHR.clipped ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::SwapchainKHR, seed, swapchainCreateInfoKHR.oldSwapchain ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct SwapchainDisplayNativeHdrCreateInfoAMD { using NativeType = VkSwapchainDisplayNativeHdrCreateInfoAMD; @@ -89265,27 +83985,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkSwapchainDisplayNativeHdrCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkSwapchainDisplayNativeHdrCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkSwapchainDisplayNativeHdrCreateInfoAMD &() VULKAN_HPP_NOEXCEPT + explicit operator VkSwapchainDisplayNativeHdrCreateInfoAMD &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, localDimmingEnable ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SwapchainDisplayNativeHdrCreateInfoAMD const & ) const = default; #else bool operator==( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( localDimmingEnable == rhs.localDimmingEnable ); + return this->reflect() == rhs.reflect(); } bool operator!=( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -89310,25 +84040,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = SwapchainDisplayNativeHdrCreateInfoAMD; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD const & - swapchainDisplayNativeHdrCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, swapchainDisplayNativeHdrCreateInfoAMD.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, swapchainDisplayNativeHdrCreateInfoAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, swapchainDisplayNativeHdrCreateInfoAMD.localDimmingEnable ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct TextureLODGatherFormatPropertiesAMD { using NativeType = VkTextureLODGatherFormatPropertiesAMD; @@ -89361,28 +84072,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkTextureLODGatherFormatPropertiesAMD const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkTextureLODGatherFormatPropertiesAMD const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkTextureLODGatherFormatPropertiesAMD &() VULKAN_HPP_NOEXCEPT + explicit operator VkTextureLODGatherFormatPropertiesAMD &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, supportsTextureGatherLODBiasAMD ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( TextureLODGatherFormatPropertiesAMD const & ) const = default; #else bool operator==( TextureLODGatherFormatPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD ); + return this->reflect() == rhs.reflect(); } bool operator!=( TextureLODGatherFormatPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -89406,25 +84126,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = TextureLODGatherFormatPropertiesAMD; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD const & - textureLODGatherFormatPropertiesAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, textureLODGatherFormatPropertiesAMD.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, textureLODGatherFormatPropertiesAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, textureLODGatherFormatPropertiesAMD.supportsTextureGatherLODBiasAMD ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct TimelineSemaphoreSubmitInfo { using NativeType = VkTimelineSemaphoreSubmitInfo; @@ -89527,31 +84228,47 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkTimelineSemaphoreSubmitInfo const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkTimelineSemaphoreSubmitInfo const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkTimelineSemaphoreSubmitInfo &() VULKAN_HPP_NOEXCEPT + explicit operator VkTimelineSemaphoreSubmitInfo &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + waitSemaphoreValueCount, + pWaitSemaphoreValues, + signalSemaphoreValueCount, + pSignalSemaphoreValues ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( TimelineSemaphoreSubmitInfo const & ) const = default; #else bool operator==( TimelineSemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( waitSemaphoreValueCount == rhs.waitSemaphoreValueCount ) && - ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) && - ( signalSemaphoreValueCount == rhs.signalSemaphoreValueCount ) && - ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues ); + return this->reflect() == rhs.reflect(); } bool operator!=( TimelineSemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -89579,27 +84296,6 @@ namespace VULKAN_HPP_NAMESPACE }; using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo const & timelineSemaphoreSubmitInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, timelineSemaphoreSubmitInfo.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, timelineSemaphoreSubmitInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, timelineSemaphoreSubmitInfo.waitSemaphoreValueCount ); - VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, timelineSemaphoreSubmitInfo.pWaitSemaphoreValues ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, timelineSemaphoreSubmitInfo.signalSemaphoreValueCount ); - VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, timelineSemaphoreSubmitInfo.pSignalSemaphoreValues ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct TraceRaysIndirectCommandKHR { using NativeType = VkTraceRaysIndirectCommandKHR; @@ -89653,27 +84349,37 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkTraceRaysIndirectCommandKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkTraceRaysIndirectCommandKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkTraceRaysIndirectCommandKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkTraceRaysIndirectCommandKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( width, height, depth ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( TraceRaysIndirectCommandKHR const & ) const = default; #else bool operator==( TraceRaysIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( width == rhs.width ) && ( height == rhs.height ) && ( depth == rhs.depth ); + return this->reflect() == rhs.reflect(); } bool operator!=( TraceRaysIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -89691,24 +84397,6 @@ namespace VULKAN_HPP_NAMESPACE std::is_nothrow_move_constructible::value, "TraceRaysIndirectCommandKHR is not nothrow_move_constructible!" ); -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR const & traceRaysIndirectCommandKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, traceRaysIndirectCommandKHR.width ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, traceRaysIndirectCommandKHR.height ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, traceRaysIndirectCommandKHR.depth ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ValidationCacheCreateInfoEXT { using NativeType = VkValidationCacheCreateInfoEXT; @@ -89789,28 +84477,41 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkValidationCacheCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkValidationCacheCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkValidationCacheCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkValidationCacheCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, initialDataSize, pInitialData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ValidationCacheCreateInfoEXT const & ) const = default; #else bool operator==( ValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( initialDataSize == rhs.initialDataSize ) && ( pInitialData == rhs.pInitialData ); + return this->reflect() == rhs.reflect(); } bool operator!=( ValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -89836,27 +84537,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ValidationCacheCreateInfoEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( - VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & validationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, validationCacheCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, validationCacheCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ValidationCacheCreateFlagsEXT, seed, validationCacheCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( size_t, seed, validationCacheCreateInfoEXT.initialDataSize ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, validationCacheCreateInfoEXT.pInitialData ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ValidationFeaturesEXT { using NativeType = VkValidationFeaturesEXT; @@ -89962,31 +84642,47 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkValidationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkValidationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkValidationFeaturesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkValidationFeaturesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + enabledValidationFeatureCount, + pEnabledValidationFeatures, + disabledValidationFeatureCount, + pDisabledValidationFeatures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ValidationFeaturesEXT const & ) const = default; #else bool operator==( ValidationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( enabledValidationFeatureCount == rhs.enabledValidationFeatureCount ) && - ( pEnabledValidationFeatures == rhs.pEnabledValidationFeatures ) && - ( disabledValidationFeatureCount == rhs.disabledValidationFeatureCount ) && - ( pDisabledValidationFeatures == rhs.pDisabledValidationFeatures ); + return this->reflect() == rhs.reflect(); } bool operator!=( ValidationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -90011,31 +84707,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ValidationFeaturesEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT const & validationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, validationFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, validationFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, validationFeaturesEXT.enabledValidationFeatureCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ValidationFeatureEnableEXT *, - seed, - validationFeaturesEXT.pEnabledValidationFeatures ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, validationFeaturesEXT.disabledValidationFeatureCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ValidationFeatureDisableEXT *, - seed, - validationFeaturesEXT.pDisabledValidationFeatures ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct ValidationFlagsEXT { using NativeType = VkValidationFlagsEXT; @@ -90108,29 +84779,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkValidationFlagsEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkValidationFlagsEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkValidationFlagsEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkValidationFlagsEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, disabledValidationCheckCount, pDisabledValidationChecks ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ValidationFlagsEXT const & ) const = default; #else bool operator==( ValidationFlagsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( disabledValidationCheckCount == rhs.disabledValidationCheckCount ) && - ( pDisabledValidationChecks == rhs.pDisabledValidationChecks ); + return this->reflect() == rhs.reflect(); } bool operator!=( ValidationFlagsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -90153,26 +84835,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = ValidationFlagsEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ValidationFlagsEXT const & validationFlagsEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, validationFlagsEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, validationFlagsEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, validationFlagsEXT.disabledValidationCheckCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::ValidationCheckEXT *, seed, validationFlagsEXT.pDisabledValidationChecks ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct VertexInputAttributeDescription2EXT { using NativeType = VkVertexInputAttributeDescription2EXT; @@ -90244,28 +84906,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVertexInputAttributeDescription2EXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVertexInputAttributeDescription2EXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVertexInputAttributeDescription2EXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVertexInputAttributeDescription2EXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, location, binding, format, offset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VertexInputAttributeDescription2EXT const & ) const = default; #else bool operator==( VertexInputAttributeDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( location == rhs.location ) && - ( binding == rhs.binding ) && ( format == rhs.format ) && ( offset == rhs.offset ); + return this->reflect() == rhs.reflect(); } bool operator!=( VertexInputAttributeDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -90292,27 +84968,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = VertexInputAttributeDescription2EXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT const & - vertexInputAttributeDescription2EXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, vertexInputAttributeDescription2EXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, vertexInputAttributeDescription2EXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription2EXT.location ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription2EXT.binding ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, vertexInputAttributeDescription2EXT.format ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputAttributeDescription2EXT.offset ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct VertexInputBindingDescription2EXT { using NativeType = VkVertexInputBindingDescription2EXT; @@ -90383,28 +85038,42 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVertexInputBindingDescription2EXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVertexInputBindingDescription2EXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVertexInputBindingDescription2EXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVertexInputBindingDescription2EXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, binding, stride, inputRate, divisor ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VertexInputBindingDescription2EXT const & ) const = default; #else bool operator==( VertexInputBindingDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( binding == rhs.binding ) && - ( stride == rhs.stride ) && ( inputRate == rhs.inputRate ) && ( divisor == rhs.divisor ); + return this->reflect() == rhs.reflect(); } bool operator!=( VertexInputBindingDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -90431,27 +85100,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = VertexInputBindingDescription2EXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT const & - vertexInputBindingDescription2EXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, vertexInputBindingDescription2EXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, vertexInputBindingDescription2EXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription2EXT.binding ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription2EXT.stride ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VertexInputRate, seed, vertexInputBindingDescription2EXT.inputRate ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, vertexInputBindingDescription2EXT.divisor ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_VI_NN ) struct ViSurfaceCreateInfoNN { @@ -90503,27 +85151,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkViSurfaceCreateInfoNN const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkViSurfaceCreateInfoNN const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkViSurfaceCreateInfoNN &() VULKAN_HPP_NOEXCEPT + explicit operator VkViSurfaceCreateInfoNN &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, window ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ViSurfaceCreateInfoNN const & ) const = default; # else bool operator==( ViSurfaceCreateInfoNN const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window ); + return this->reflect() == rhs.reflect(); } bool operator!=( ViSurfaceCreateInfoNN const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -90545,26 +85206,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = ViSurfaceCreateInfoNN; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & viSurfaceCreateInfoNN ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, viSurfaceCreateInfoNN.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, viSurfaceCreateInfoNN.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ViSurfaceCreateFlagsNN, seed, viSurfaceCreateInfoNN.flags ); - VULKAN_HPP_HASH_COMBINE( void *, seed, viSurfaceCreateInfoNN.window ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_VI_NN*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -90637,29 +85278,42 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoPictureResourceKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoPictureResourceKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoPictureResourceKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoPictureResourceKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, codedOffset, codedExtent, baseArrayLayer, imageViewBinding ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoPictureResourceKHR const & ) const = default; # else bool operator==( VideoPictureResourceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( codedOffset == rhs.codedOffset ) && - ( codedExtent == rhs.codedExtent ) && ( baseArrayLayer == rhs.baseArrayLayer ) && - ( imageViewBinding == rhs.imageViewBinding ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoPictureResourceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -90684,28 +85338,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoPictureResourceKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR const & videoPictureResourceKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoPictureResourceKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoPictureResourceKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, videoPictureResourceKHR.codedOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoPictureResourceKHR.codedExtent ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoPictureResourceKHR.baseArrayLayer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::ImageView, seed, videoPictureResourceKHR.imageViewBinding ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -90760,28 +85392,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoReferenceSlotKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoReferenceSlotKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoReferenceSlotKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoReferenceSlotKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, slotIndex, pPictureResource ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoReferenceSlotKHR const & ) const = default; # else bool operator==( VideoReferenceSlotKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) && - ( pPictureResource == rhs.pPictureResource ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoReferenceSlotKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -90803,27 +85447,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoReferenceSlotKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR const & videoReferenceSlotKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoReferenceSlotKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoReferenceSlotKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( int8_t, seed, videoReferenceSlotKHR.slotIndex ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR *, seed, videoReferenceSlotKHR.pPictureResource ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -90943,30 +85566,51 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoBeginCodingInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoBeginCodingInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoBeginCodingInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoBeginCodingInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + codecQualityPreset, + videoSession, + videoSessionParameters, + referenceSlotCount, + pReferenceSlots ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoBeginCodingInfoKHR const & ) const = default; # else bool operator==( VideoBeginCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( codecQualityPreset == rhs.codecQualityPreset ) && ( videoSession == rhs.videoSession ) && - ( videoSessionParameters == rhs.videoSessionParameters ) && - ( referenceSlotCount == rhs.referenceSlotCount ) && ( pReferenceSlots == rhs.pReferenceSlots ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoBeginCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -90993,33 +85637,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoBeginCodingInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR const & videoBeginCodingInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoBeginCodingInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoBeginCodingInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoBeginCodingFlagsKHR, seed, videoBeginCodingInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoCodingQualityPresetFlagsKHR, seed, videoBeginCodingInfoKHR.codecQualityPreset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoSessionKHR, seed, videoBeginCodingInfoKHR.videoSession ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, seed, videoBeginCodingInfoKHR.videoSessionParameters ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoBeginCodingInfoKHR.referenceSlotCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoBeginCodingInfoKHR.pReferenceSlots ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -91091,28 +85708,42 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoBindMemoryKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoBindMemoryKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoBindMemoryKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoBindMemoryKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryBindIndex, memory, memoryOffset, memorySize ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoBindMemoryKHR const & ) const = default; # else bool operator==( VideoBindMemoryKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) && - ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ) && ( memorySize == rhs.memorySize ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoBindMemoryKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -91136,28 +85767,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoBindMemoryKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR const & videoBindMemoryKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoBindMemoryKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoBindMemoryKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoBindMemoryKHR.memoryBindIndex ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceMemory, seed, videoBindMemoryKHR.memory ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoBindMemoryKHR.memoryOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoBindMemoryKHR.memorySize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -91202,33 +85811,55 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkVideoCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + capabilityFlags, + minBitstreamBufferOffsetAlignment, + minBitstreamBufferSizeAlignment, + videoPictureExtentGranularity, + minExtent, + maxExtent, + maxReferencePicturesSlotsCount, + maxReferencePicturesActiveCount ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoCapabilitiesKHR const & ) const = default; # else bool operator==( VideoCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( capabilityFlags == rhs.capabilityFlags ) && - ( minBitstreamBufferOffsetAlignment == rhs.minBitstreamBufferOffsetAlignment ) && - ( minBitstreamBufferSizeAlignment == rhs.minBitstreamBufferSizeAlignment ) && - ( videoPictureExtentGranularity == rhs.videoPictureExtentGranularity ) && ( minExtent == rhs.minExtent ) && - ( maxExtent == rhs.maxExtent ) && - ( maxReferencePicturesSlotsCount == rhs.maxReferencePicturesSlotsCount ) && - ( maxReferencePicturesActiveCount == rhs.maxReferencePicturesActiveCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -91256,35 +85887,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoCapabilitiesKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR const & videoCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoCapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, videoCapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoCapabilityFlagsKHR, seed, videoCapabilitiesKHR.capabilityFlags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoCapabilitiesKHR.minBitstreamBufferOffsetAlignment ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoCapabilitiesKHR.minBitstreamBufferSizeAlignment ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoCapabilitiesKHR.videoPictureExtentGranularity ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoCapabilitiesKHR.minExtent ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoCapabilitiesKHR.maxExtent ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoCapabilitiesKHR.maxReferencePicturesSlotsCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoCapabilitiesKHR.maxReferencePicturesActiveCount ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -91332,27 +85934,39 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoCodingControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoCodingControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoCodingControlInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoCodingControlInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoCodingControlInfoKHR const & ) const = default; # else bool operator==( VideoCodingControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoCodingControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -91374,25 +85988,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoCodingControlInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR const & videoCodingControlInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoCodingControlInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoCodingControlInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoCodingControlFlagsKHR, seed, videoCodingControlInfoKHR.flags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -91430,29 +86025,41 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkVideoDecodeH264CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH264CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoDecodeH264CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH264CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxLevel, fieldOffsetGranularity, stdExtensionVersion ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264CapabilitiesEXT const & ) const = default; # else bool operator==( VideoDecodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxLevel == rhs.maxLevel ) && - ( fieldOffsetGranularity == rhs.fieldOffsetGranularity ) && - ( stdExtensionVersion == rhs.stdExtensionVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -91477,29 +86084,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoDecodeH264CapabilitiesEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesEXT const & videoDecodeH264CapabilitiesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264CapabilitiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, videoDecodeH264CapabilitiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264CapabilitiesEXT.maxLevel ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Offset2D, seed, videoDecodeH264CapabilitiesEXT.fieldOffsetGranularity ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExtensionProperties, seed, videoDecodeH264CapabilitiesEXT.stdExtensionVersion ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -91548,27 +86132,39 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoDecodeH264DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH264DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoDecodeH264DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH264DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdReferenceInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264DpbSlotInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -91591,26 +86187,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoDecodeH264DpbSlotInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoEXT const & videoDecodeH264DpbSlotInfoEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264DpbSlotInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264DpbSlotInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - const StdVideoDecodeH264ReferenceInfo *, seed, videoDecodeH264DpbSlotInfoEXT.pStdReferenceInfo ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -91656,27 +86232,37 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoDecodeH264MvcEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH264MvcEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoDecodeH264MvcEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH264MvcEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdMvc ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264MvcEXT const & ) const = default; # else bool operator==( VideoDecodeH264MvcEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdMvc == rhs.pStdMvc ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH264MvcEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -91697,25 +86283,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoDecodeH264MvcEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264MvcEXT const & videoDecodeH264MvcEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264MvcEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264MvcEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( const StdVideoDecodeH264Mvc *, seed, videoDecodeH264MvcEXT.pStdMvc ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -91800,28 +86367,41 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoDecodeH264PictureInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH264PictureInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoDecodeH264PictureInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH264PictureInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdPictureInfo, slicesCount, pSlicesDataOffsets ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264PictureInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH264PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && - ( slicesCount == rhs.slicesCount ) && ( pSlicesDataOffsets == rhs.pSlicesDataOffsets ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH264PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -91846,28 +86426,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoDecodeH264PictureInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoEXT const & videoDecodeH264PictureInfoEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264PictureInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264PictureInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - const StdVideoDecodeH264PictureInfo *, seed, videoDecodeH264PictureInfoEXT.pStdPictureInfo ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264PictureInfoEXT.slicesCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, videoDecodeH264PictureInfoEXT.pSlicesDataOffsets ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -91924,29 +86482,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoDecodeH264ProfileEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH264ProfileEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoDecodeH264ProfileEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH264ProfileEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdProfileIdc, pictureLayout ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264ProfileEXT const & ) const = default; # else bool operator==( VideoDecodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 ) && - ( pictureLayout == rhs.pictureLayout ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -91969,27 +86538,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoDecodeH264ProfileEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileEXT const & videoDecodeH264ProfileEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264ProfileEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264ProfileEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( StdVideoH264ProfileIdc, seed, videoDecodeH264ProfileEXT.stdProfileIdc ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsEXT, seed, videoDecodeH264ProfileEXT.pictureLayout ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -92049,28 +86597,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoDecodeH264SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH264SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoDecodeH264SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH264SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pStdExtensionVersion ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264SessionCreateInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( pStdExtensionVersion == rhs.pStdExtensionVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -92094,29 +86654,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoDecodeH264SessionCreateInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionCreateInfoEXT const & - videoDecodeH264SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264SessionCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264SessionCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoDecodeH264CreateFlagsEXT, seed, videoDecodeH264SessionCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ExtensionProperties *, - seed, - videoDecodeH264SessionCreateInfoEXT.pStdExtensionVersion ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -92230,28 +86767,42 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoDecodeH264SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH264SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoDecodeH264SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH264SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, spsStdCount, pSpsStd, ppsStdCount, pPpsStd ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264SessionParametersAddInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsStdCount == rhs.spsStdCount ) && - ( pSpsStd == rhs.pSpsStd ) && ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -92278,31 +86829,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoDecodeH264SessionParametersAddInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoEXT const & - videoDecodeH264SessionParametersAddInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264SessionParametersAddInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264SessionParametersAddInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264SessionParametersAddInfoEXT.spsStdCount ); - VULKAN_HPP_HASH_COMBINE( - const StdVideoH264SequenceParameterSet *, seed, videoDecodeH264SessionParametersAddInfoEXT.pSpsStd ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264SessionParametersAddInfoEXT.ppsStdCount ); - VULKAN_HPP_HASH_COMBINE( - const StdVideoH264PictureParameterSet *, seed, videoDecodeH264SessionParametersAddInfoEXT.pPpsStd ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -92375,28 +86901,41 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoDecodeH264SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH264SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoDecodeH264SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH264SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264SessionParametersCreateInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSpsStdCount == rhs.maxSpsStdCount ) && - ( maxPpsStdCount == rhs.maxPpsStdCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -92422,30 +86961,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoDecodeH264SessionParametersCreateInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoEXT const & - videoDecodeH264SessionParametersCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH264SessionParametersCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH264SessionParametersCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264SessionParametersCreateInfoEXT.maxSpsStdCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH264SessionParametersCreateInfoEXT.maxPpsStdCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoEXT *, - seed, - videoDecodeH264SessionParametersCreateInfoEXT.pParametersAddInfo ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -92480,28 +86995,40 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkVideoDecodeH265CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH265CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoDecodeH265CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH265CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxLevel, stdExtensionVersion ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265CapabilitiesEXT const & ) const = default; # else bool operator==( VideoDecodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxLevel == rhs.maxLevel ) && - ( stdExtensionVersion == rhs.stdExtensionVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -92525,27 +87052,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoDecodeH265CapabilitiesEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesEXT const & videoDecodeH265CapabilitiesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265CapabilitiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, videoDecodeH265CapabilitiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265CapabilitiesEXT.maxLevel ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExtensionProperties, seed, videoDecodeH265CapabilitiesEXT.stdExtensionVersion ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -92594,27 +87100,39 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoDecodeH265DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH265DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoDecodeH265DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH265DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdReferenceInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265DpbSlotInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -92637,26 +87155,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoDecodeH265DpbSlotInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoEXT const & videoDecodeH265DpbSlotInfoEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265DpbSlotInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265DpbSlotInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - const StdVideoDecodeH265ReferenceInfo *, seed, videoDecodeH265DpbSlotInfoEXT.pStdReferenceInfo ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -92741,28 +87239,41 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoDecodeH265PictureInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH265PictureInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoDecodeH265PictureInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH265PictureInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdPictureInfo, slicesCount, pSlicesDataOffsets ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265PictureInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH265PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && - ( slicesCount == rhs.slicesCount ) && ( pSlicesDataOffsets == rhs.pSlicesDataOffsets ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH265PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -92787,27 +87298,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoDecodeH265PictureInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoEXT const & videoDecodeH265PictureInfoEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265PictureInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265PictureInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( StdVideoDecodeH265PictureInfo *, seed, videoDecodeH265PictureInfoEXT.pStdPictureInfo ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265PictureInfoEXT.slicesCount ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, videoDecodeH265PictureInfoEXT.pSlicesDataOffsets ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -92854,28 +87344,37 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoDecodeH265ProfileEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH265ProfileEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoDecodeH265ProfileEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH265ProfileEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdProfileIdc ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265ProfileEXT const & ) const = default; # else bool operator==( VideoDecodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -92897,25 +87396,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoDecodeH265ProfileEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileEXT const & videoDecodeH265ProfileEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265ProfileEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265ProfileEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( StdVideoH265ProfileIdc, seed, videoDecodeH265ProfileEXT.stdProfileIdc ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -92975,28 +87455,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoDecodeH265SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH265SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoDecodeH265SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH265SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pStdExtensionVersion ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265SessionCreateInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( pStdExtensionVersion == rhs.pStdExtensionVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -93020,29 +87512,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoDecodeH265SessionCreateInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionCreateInfoEXT const & - videoDecodeH265SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265SessionCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265SessionCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoDecodeH265CreateFlagsEXT, seed, videoDecodeH265SessionCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ExtensionProperties *, - seed, - videoDecodeH265SessionCreateInfoEXT.pStdExtensionVersion ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -93156,28 +87625,42 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoDecodeH265SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH265SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoDecodeH265SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH265SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, spsStdCount, pSpsStd, ppsStdCount, pPpsStd ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265SessionParametersAddInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsStdCount == rhs.spsStdCount ) && - ( pSpsStd == rhs.pSpsStd ) && ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -93204,31 +87687,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoDecodeH265SessionParametersAddInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoEXT const & - videoDecodeH265SessionParametersAddInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265SessionParametersAddInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265SessionParametersAddInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265SessionParametersAddInfoEXT.spsStdCount ); - VULKAN_HPP_HASH_COMBINE( - const StdVideoH265SequenceParameterSet *, seed, videoDecodeH265SessionParametersAddInfoEXT.pSpsStd ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265SessionParametersAddInfoEXT.ppsStdCount ); - VULKAN_HPP_HASH_COMBINE( - const StdVideoH265PictureParameterSet *, seed, videoDecodeH265SessionParametersAddInfoEXT.pPpsStd ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -93301,28 +87759,41 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoDecodeH265SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH265SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoDecodeH265SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeH265SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265SessionParametersCreateInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSpsStdCount == rhs.maxSpsStdCount ) && - ( maxPpsStdCount == rhs.maxPpsStdCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -93348,30 +87819,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoDecodeH265SessionParametersCreateInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoEXT const & - videoDecodeH265SessionParametersCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeH265SessionParametersCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeH265SessionParametersCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265SessionParametersCreateInfoEXT.maxSpsStdCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeH265SessionParametersCreateInfoEXT.maxPpsStdCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoEXT *, - seed, - videoDecodeH265SessionParametersCreateInfoEXT.pParametersAddInfo ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -93535,32 +87982,59 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoDecodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoDecodeInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoDecodeInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + codedOffset, + codedExtent, + srcBuffer, + srcBufferOffset, + srcBufferRange, + dstPictureResource, + pSetupReferenceSlot, + referenceSlotCount, + pReferenceSlots ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeInfoKHR const & ) const = default; # else bool operator==( VideoDecodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( codedOffset == rhs.codedOffset ) && ( codedExtent == rhs.codedExtent ) && - ( srcBuffer == rhs.srcBuffer ) && ( srcBufferOffset == rhs.srcBufferOffset ) && - ( srcBufferRange == rhs.srcBufferRange ) && ( dstPictureResource == rhs.dstPictureResource ) && - ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) && ( referenceSlotCount == rhs.referenceSlotCount ) && - ( pReferenceSlots == rhs.pReferenceSlots ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -93590,37 +88064,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoDecodeInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR const & videoDecodeInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoDecodeInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoDecodeInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoDecodeFlagsKHR, seed, videoDecodeInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Offset2D, seed, videoDecodeInfoKHR.codedOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoDecodeInfoKHR.codedExtent ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, videoDecodeInfoKHR.srcBuffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoDecodeInfoKHR.srcBufferOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoDecodeInfoKHR.srcBufferRange ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR, seed, videoDecodeInfoKHR.dstPictureResource ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoDecodeInfoKHR.pSetupReferenceSlot ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoDecodeInfoKHR.referenceSlotCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoDecodeInfoKHR.pReferenceSlots ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -93759,33 +88202,61 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH264CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH264CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + inputModeFlags, + outputModeFlags, + minPictureSizeInMbs, + maxPictureSizeInMbs, + inputImageDataAlignment, + maxNumL0ReferenceForP, + maxNumL0ReferenceForB, + maxNumL1Reference, + qualityLevelCount, + stdExtensionVersion ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264CapabilitiesEXT const & ) const = default; # else bool operator==( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( inputModeFlags == rhs.inputModeFlags ) && ( outputModeFlags == rhs.outputModeFlags ) && - ( minPictureSizeInMbs == rhs.minPictureSizeInMbs ) && ( maxPictureSizeInMbs == rhs.maxPictureSizeInMbs ) && - ( inputImageDataAlignment == rhs.inputImageDataAlignment ) && - ( maxNumL0ReferenceForP == rhs.maxNumL0ReferenceForP ) && - ( maxNumL0ReferenceForB == rhs.maxNumL0ReferenceForB ) && ( maxNumL1Reference == rhs.maxNumL1Reference ) && - ( qualityLevelCount == rhs.qualityLevelCount ) && ( stdExtensionVersion == rhs.stdExtensionVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -93818,40 +88289,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH264CapabilitiesEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT const & videoEncodeH264CapabilitiesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264CapabilitiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264CapabilitiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT, seed, videoEncodeH264CapabilitiesEXT.flags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT, seed, videoEncodeH264CapabilitiesEXT.inputModeFlags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT, seed, videoEncodeH264CapabilitiesEXT.outputModeFlags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH264CapabilitiesEXT.minPictureSizeInMbs ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH264CapabilitiesEXT.maxPictureSizeInMbs ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH264CapabilitiesEXT.inputImageDataAlignment ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264CapabilitiesEXT.maxNumL0ReferenceForP ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264CapabilitiesEXT.maxNumL0ReferenceForB ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264CapabilitiesEXT.maxNumL1Reference ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264CapabilitiesEXT.qualityLevelCount ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExtensionProperties, seed, videoEncodeH264CapabilitiesEXT.stdExtensionVersion ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -93908,28 +88345,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH264DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH264DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, slotIndex, pStdPictureInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264DpbSlotInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) && - ( pStdPictureInfo == rhs.pStdPictureInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -93953,27 +88402,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH264DpbSlotInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT const & videoEncodeH264DpbSlotInfoEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264DpbSlotInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264DpbSlotInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( int8_t, seed, videoEncodeH264DpbSlotInfoEXT.slotIndex ); - VULKAN_HPP_HASH_COMBINE( - const StdVideoEncodeH264PictureInfo *, seed, videoEncodeH264DpbSlotInfoEXT.pStdPictureInfo ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -94074,29 +88502,42 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH264EmitPictureParametersEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264EmitPictureParametersEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH264EmitPictureParametersEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264EmitPictureParametersEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, spsId, emitSpsEnable, ppsIdEntryCount, ppsIdEntries ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264EmitPictureParametersEXT const & ) const = default; # else bool operator==( VideoEncodeH264EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsId == rhs.spsId ) && - ( emitSpsEnable == rhs.emitSpsEnable ) && ( ppsIdEntryCount == rhs.ppsIdEntryCount ) && - ( ppsIdEntries == rhs.ppsIdEntries ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -94123,29 +88564,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH264EmitPictureParametersEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264EmitPictureParametersEXT const & - videoEncodeH264EmitPictureParametersEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264EmitPictureParametersEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264EmitPictureParametersEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264EmitPictureParametersEXT.spsId ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264EmitPictureParametersEXT.emitSpsEnable ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264EmitPictureParametersEXT.ppsIdEntryCount ); - VULKAN_HPP_HASH_COMBINE( const uint8_t *, seed, videoEncodeH264EmitPictureParametersEXT.ppsIdEntries ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -94198,27 +88616,37 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH264FrameSizeEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264FrameSizeEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH264FrameSizeEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264FrameSizeEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( frameISize, framePSize, frameBSize ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264FrameSizeEXT const & ) const = default; # else bool operator==( VideoEncodeH264FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( frameISize == rhs.frameISize ) && ( framePSize == rhs.framePSize ) && ( frameBSize == rhs.frameBSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -94235,25 +88663,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "VideoEncodeH264FrameSizeEXT is not nothrow_move_constructible!" ); - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT const & videoEncodeH264FrameSizeEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264FrameSizeEXT.frameISize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264FrameSizeEXT.framePSize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264FrameSizeEXT.frameBSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -94384,31 +88793,51 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH264NaluSliceEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264NaluSliceEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH264NaluSliceEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264NaluSliceEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + pSliceHeaderStd, + mbCount, + refFinalList0EntryCount, + pRefFinalList0Entries, + refFinalList1EntryCount, + pRefFinalList1Entries ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264NaluSliceEXT const & ) const = default; # else bool operator==( VideoEncodeH264NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pSliceHeaderStd == rhs.pSliceHeaderStd ) && - ( mbCount == rhs.mbCount ) && ( refFinalList0EntryCount == rhs.refFinalList0EntryCount ) && - ( pRefFinalList0Entries == rhs.pRefFinalList0Entries ) && - ( refFinalList1EntryCount == rhs.refFinalList1EntryCount ) && - ( pRefFinalList1Entries == rhs.pRefFinalList1Entries ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -94436,34 +88865,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH264NaluSliceEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT const & videoEncodeH264NaluSliceEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264NaluSliceEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264NaluSliceEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( const StdVideoEncodeH264SliceHeader *, seed, videoEncodeH264NaluSliceEXT.pSliceHeaderStd ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264NaluSliceEXT.mbCount ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264NaluSliceEXT.refFinalList0EntryCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *, - seed, - videoEncodeH264NaluSliceEXT.pRefFinalList0Entries ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264NaluSliceEXT.refFinalList1EntryCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *, - seed, - videoEncodeH264NaluSliceEXT.pRefFinalList1Entries ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -94510,28 +88911,37 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH264ProfileEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264ProfileEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH264ProfileEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264ProfileEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdProfileIdc ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264ProfileEXT const & ) const = default; # else bool operator==( VideoEncodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -94553,25 +88963,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH264ProfileEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileEXT const & videoEncodeH264ProfileEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264ProfileEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264ProfileEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( StdVideoH264ProfileIdc, seed, videoEncodeH264ProfileEXT.stdProfileIdc ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -94622,27 +89013,37 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH264QpEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264QpEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH264QpEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264QpEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( qpI, qpP, qpB ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264QpEXT const & ) const = default; # else bool operator==( VideoEncodeH264QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -94657,25 +89058,6 @@ namespace VULKAN_HPP_NAMESPACE "struct wrapper is not a standard layout!" ); VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "VideoEncodeH264QpEXT is not nothrow_move_constructible!" ); - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const & videoEncodeH264QpEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH264QpEXT.qpI ); - VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH264QpEXT.qpP ); - VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH264QpEXT.qpB ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -94693,11 +89075,13 @@ namespace VULKAN_HPP_NAMESPACE uint32_t idrPeriod_ = {}, uint32_t consecutiveBFrameCount_ = {}, VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT rateControlStructure_ = - VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT::eUnknown ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT::eUnknown, + uint8_t temporalLayerCount_ = {} ) VULKAN_HPP_NOEXCEPT : gopFrameCount( gopFrameCount_ ) , idrPeriod( idrPeriod_ ) , consecutiveBFrameCount( consecutiveBFrameCount_ ) , rateControlStructure( rateControlStructure_ ) + , temporalLayerCount( temporalLayerCount_ ) {} VULKAN_HPP_CONSTEXPR @@ -94750,31 +89134,53 @@ namespace VULKAN_HPP_NAMESPACE rateControlStructure = rateControlStructure_; return *this; } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & + setTemporalLayerCount( uint8_t temporalLayerCount_ ) VULKAN_HPP_NOEXCEPT + { + temporalLayerCount = temporalLayerCount_; + return *this; + } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH264RateControlInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264RateControlInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH264RateControlInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264RateControlInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, gopFrameCount, idrPeriod, consecutiveBFrameCount, rateControlStructure, temporalLayerCount ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264RateControlInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( gopFrameCount == rhs.gopFrameCount ) && - ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) && - ( rateControlStructure == rhs.rateControlStructure ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -94786,6 +89192,7 @@ namespace VULKAN_HPP_NAMESPACE uint32_t consecutiveBFrameCount = {}; VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT rateControlStructure = VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT::eUnknown; + uint8_t temporalLayerCount = {}; }; VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT ) == sizeof( VkVideoEncodeH264RateControlInfoEXT ), @@ -94801,30 +89208,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH264RateControlInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT const & - videoEncodeH264RateControlInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264RateControlInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264RateControlInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264RateControlInfoEXT.gopFrameCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264RateControlInfoEXT.idrPeriod ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264RateControlInfoEXT.consecutiveBFrameCount ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT, - seed, - videoEncodeH264RateControlInfoEXT.rateControlStructure ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -94948,31 +89331,57 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH264RateControlLayerInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264RateControlLayerInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH264RateControlLayerInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264RateControlLayerInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + temporalLayerId, + useInitialRcQp, + initialRcQp, + useMinQp, + minQp, + useMaxQp, + maxQp, + useMaxFrameSize, + maxFrameSize ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264RateControlLayerInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( temporalLayerId == rhs.temporalLayerId ) && - ( useInitialRcQp == rhs.useInitialRcQp ) && ( initialRcQp == rhs.initialRcQp ) && - ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) && - ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) && - ( maxFrameSize == rhs.maxFrameSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -95004,39 +89413,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH264RateControlLayerInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoEXT const & - videoEncodeH264RateControlLayerInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264RateControlLayerInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264RateControlLayerInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264RateControlLayerInfoEXT.temporalLayerId ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264RateControlLayerInfoEXT.useInitialRcQp ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT, seed, videoEncodeH264RateControlLayerInfoEXT.initialRcQp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264RateControlLayerInfoEXT.useMinQp ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT, seed, videoEncodeH264RateControlLayerInfoEXT.minQp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264RateControlLayerInfoEXT.useMaxQp ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT, seed, videoEncodeH264RateControlLayerInfoEXT.maxQp ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH264RateControlLayerInfoEXT.useMaxFrameSize ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT, seed, videoEncodeH264RateControlLayerInfoEXT.maxFrameSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -95105,28 +89481,41 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH264SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH264SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, maxPictureSizeInMbs, pStdExtensionVersion ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264SessionCreateInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( maxPictureSizeInMbs == rhs.maxPictureSizeInMbs ) && ( pStdExtensionVersion == rhs.pStdExtensionVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -95151,31 +89540,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH264SessionCreateInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoEXT const & - videoEncodeH264SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264SessionCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264SessionCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoEncodeH264CreateFlagsEXT, seed, videoEncodeH264SessionCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH264SessionCreateInfoEXT.maxPictureSizeInMbs ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ExtensionProperties *, - seed, - videoEncodeH264SessionCreateInfoEXT.pStdExtensionVersion ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -95289,28 +89653,42 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH264SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH264SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, spsStdCount, pSpsStd, ppsStdCount, pPpsStd ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264SessionParametersAddInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsStdCount == rhs.spsStdCount ) && - ( pSpsStd == rhs.pSpsStd ) && ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -95337,31 +89715,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH264SessionParametersAddInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT const & - videoEncodeH264SessionParametersAddInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264SessionParametersAddInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264SessionParametersAddInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264SessionParametersAddInfoEXT.spsStdCount ); - VULKAN_HPP_HASH_COMBINE( - const StdVideoH264SequenceParameterSet *, seed, videoEncodeH264SessionParametersAddInfoEXT.pSpsStd ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264SessionParametersAddInfoEXT.ppsStdCount ); - VULKAN_HPP_HASH_COMBINE( - const StdVideoH264PictureParameterSet *, seed, videoEncodeH264SessionParametersAddInfoEXT.pPpsStd ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -95434,28 +89787,41 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH264SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH264SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264SessionParametersCreateInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSpsStdCount == rhs.maxSpsStdCount ) && - ( maxPpsStdCount == rhs.maxPpsStdCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -95481,30 +89847,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH264SessionParametersCreateInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoEXT const & - videoEncodeH264SessionParametersCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264SessionParametersCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264SessionParametersCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264SessionParametersCreateInfoEXT.maxSpsStdCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264SessionParametersCreateInfoEXT.maxPpsStdCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT *, - seed, - videoEncodeH264SessionParametersCreateInfoEXT.pParametersAddInfo ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -95659,33 +90001,53 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH264VclFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264VclFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH264VclFrameInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH264VclFrameInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + refDefaultFinalList0EntryCount, + pRefDefaultFinalList0Entries, + refDefaultFinalList1EntryCount, + pRefDefaultFinalList1Entries, + naluSliceEntryCount, + pNaluSliceEntries, + pCurrentPictureInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264VclFrameInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( refDefaultFinalList0EntryCount == rhs.refDefaultFinalList0EntryCount ) && - ( pRefDefaultFinalList0Entries == rhs.pRefDefaultFinalList0Entries ) && - ( refDefaultFinalList1EntryCount == rhs.refDefaultFinalList1EntryCount ) && - ( pRefDefaultFinalList1Entries == rhs.pRefDefaultFinalList1Entries ) && - ( naluSliceEntryCount == rhs.naluSliceEntryCount ) && ( pNaluSliceEntries == rhs.pNaluSliceEntries ) && - ( pCurrentPictureInfo == rhs.pCurrentPictureInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -95714,39 +90076,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH264VclFrameInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264VclFrameInfoEXT const & videoEncodeH264VclFrameInfoEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH264VclFrameInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH264VclFrameInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264VclFrameInfoEXT.refDefaultFinalList0EntryCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *, - seed, - videoEncodeH264VclFrameInfoEXT.pRefDefaultFinalList0Entries ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH264VclFrameInfoEXT.refDefaultFinalList1EntryCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *, - seed, - videoEncodeH264VclFrameInfoEXT.pRefDefaultFinalList1Entries ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH264VclFrameInfoEXT.naluSliceEntryCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT *, - seed, - videoEncodeH264VclFrameInfoEXT.pNaluSliceEntries ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT *, - seed, - videoEncodeH264VclFrameInfoEXT.pCurrentPictureInfo ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -95885,33 +90214,61 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH265CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265CapabilitiesEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + inputModeFlags, + outputModeFlags, + ctbSizes, + inputImageDataAlignment, + maxNumL0ReferenceForP, + maxNumL0ReferenceForB, + maxNumL1Reference, + maxNumSubLayers, + qualityLevelCount, + stdExtensionVersion ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265CapabilitiesEXT const & ) const = default; # else bool operator==( VideoEncodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( inputModeFlags == rhs.inputModeFlags ) && ( outputModeFlags == rhs.outputModeFlags ) && - ( ctbSizes == rhs.ctbSizes ) && ( inputImageDataAlignment == rhs.inputImageDataAlignment ) && - ( maxNumL0ReferenceForP == rhs.maxNumL0ReferenceForP ) && - ( maxNumL0ReferenceForB == rhs.maxNumL0ReferenceForB ) && ( maxNumL1Reference == rhs.maxNumL1Reference ) && - ( maxNumSubLayers == rhs.maxNumSubLayers ) && ( qualityLevelCount == rhs.qualityLevelCount ) && - ( stdExtensionVersion == rhs.stdExtensionVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -95944,41 +90301,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH265CapabilitiesEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesEXT const & videoEncodeH265CapabilitiesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265CapabilitiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265CapabilitiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT, seed, videoEncodeH265CapabilitiesEXT.flags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoEncodeH265InputModeFlagsEXT, seed, videoEncodeH265CapabilitiesEXT.inputModeFlags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoEncodeH265OutputModeFlagsEXT, seed, videoEncodeH265CapabilitiesEXT.outputModeFlags ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT, seed, videoEncodeH265CapabilitiesEXT.ctbSizes ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeH265CapabilitiesEXT.inputImageDataAlignment ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.maxNumL0ReferenceForP ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.maxNumL0ReferenceForB ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.maxNumL1Reference ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.maxNumSubLayers ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265CapabilitiesEXT.qualityLevelCount ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::ExtensionProperties, seed, videoEncodeH265CapabilitiesEXT.stdExtensionVersion ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -96034,28 +90356,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265DpbSlotInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH265DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265DpbSlotInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, slotIndex, pStdReferenceInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265DpbSlotInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) && - ( pStdReferenceInfo == rhs.pStdReferenceInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -96079,27 +90413,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH265DpbSlotInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT const & videoEncodeH265DpbSlotInfoEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265DpbSlotInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265DpbSlotInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( int8_t, seed, videoEncodeH265DpbSlotInfoEXT.slotIndex ); - VULKAN_HPP_HASH_COMBINE( - const StdVideoEncodeH265ReferenceInfo *, seed, videoEncodeH265DpbSlotInfoEXT.pStdReferenceInfo ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -96221,29 +90534,44 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265EmitPictureParametersEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265EmitPictureParametersEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH265EmitPictureParametersEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265EmitPictureParametersEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vpsId, spsId, emitVpsEnable, emitSpsEnable, ppsIdEntryCount, ppsIdEntries ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265EmitPictureParametersEXT const & ) const = default; # else bool operator==( VideoEncodeH265EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vpsId == rhs.vpsId ) && ( spsId == rhs.spsId ) && - ( emitVpsEnable == rhs.emitVpsEnable ) && ( emitSpsEnable == rhs.emitSpsEnable ) && - ( ppsIdEntryCount == rhs.ppsIdEntryCount ) && ( ppsIdEntries == rhs.ppsIdEntries ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -96272,32 +90600,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH265EmitPictureParametersEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265EmitPictureParametersEXT const & - videoEncodeH265EmitPictureParametersEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265EmitPictureParametersEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265EmitPictureParametersEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265EmitPictureParametersEXT.vpsId ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265EmitPictureParametersEXT.spsId ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265EmitPictureParametersEXT.emitVpsEnable ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265EmitPictureParametersEXT.emitSpsEnable ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265EmitPictureParametersEXT.ppsIdEntryCount ); - VULKAN_HPP_HASH_COMBINE( const uint8_t *, seed, videoEncodeH265EmitPictureParametersEXT.ppsIdEntries ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -96350,27 +90652,37 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265FrameSizeEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265FrameSizeEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH265FrameSizeEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265FrameSizeEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( frameISize, framePSize, frameBSize ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265FrameSizeEXT const & ) const = default; # else bool operator==( VideoEncodeH265FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( frameISize == rhs.frameISize ) && ( framePSize == rhs.framePSize ) && ( frameBSize == rhs.frameBSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -96387,25 +90699,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "VideoEncodeH265FrameSizeEXT is not nothrow_move_constructible!" ); - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT const & videoEncodeH265FrameSizeEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265FrameSizeEXT.frameISize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265FrameSizeEXT.framePSize ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265FrameSizeEXT.frameBSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -96527,32 +90820,49 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265ReferenceListsEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265ReferenceListsEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH265ReferenceListsEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265ReferenceListsEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + referenceList0EntryCount, + pReferenceList0Entries, + referenceList1EntryCount, + pReferenceList1Entries, + pReferenceModifications ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265ReferenceListsEXT const & ) const = default; # else bool operator==( VideoEncodeH265ReferenceListsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( referenceList0EntryCount == rhs.referenceList0EntryCount ) && - ( pReferenceList0Entries == rhs.pReferenceList0Entries ) && - ( referenceList1EntryCount == rhs.referenceList1EntryCount ) && - ( pReferenceList1Entries == rhs.pReferenceList1Entries ) && - ( pReferenceModifications == rhs.pReferenceModifications ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265ReferenceListsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -96579,36 +90889,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH265ReferenceListsEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT const & videoEncodeH265ReferenceListsEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265ReferenceListsEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265ReferenceListsEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265ReferenceListsEXT.referenceList0EntryCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT *, - seed, - videoEncodeH265ReferenceListsEXT.pReferenceList0Entries ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265ReferenceListsEXT.referenceList1EntryCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT *, - seed, - videoEncodeH265ReferenceListsEXT.pReferenceList1Entries ); - VULKAN_HPP_HASH_COMBINE( const StdVideoEncodeH265ReferenceModifications *, - seed, - videoEncodeH265ReferenceListsEXT.pReferenceModifications ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -96673,28 +90953,41 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265NaluSliceEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265NaluSliceEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH265NaluSliceEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265NaluSliceEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, ctbCount, pReferenceFinalLists, pSliceHeaderStd ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265NaluSliceEXT const & ) const = default; # else bool operator==( VideoEncodeH265NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ctbCount == rhs.ctbCount ) && - ( pReferenceFinalLists == rhs.pReferenceFinalLists ) && ( pSliceHeaderStd == rhs.pSliceHeaderStd ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -96719,29 +91012,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH265NaluSliceEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT const & videoEncodeH265NaluSliceEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265NaluSliceEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265NaluSliceEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265NaluSliceEXT.ctbCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT *, - seed, - videoEncodeH265NaluSliceEXT.pReferenceFinalLists ); - VULKAN_HPP_HASH_COMBINE( const StdVideoEncodeH265SliceHeader *, seed, videoEncodeH265NaluSliceEXT.pSliceHeaderStd ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -96788,28 +91058,37 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265ProfileEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265ProfileEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH265ProfileEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265ProfileEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdProfileIdc ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265ProfileEXT const & ) const = default; # else bool operator==( VideoEncodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -96831,25 +91110,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH265ProfileEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileEXT const & videoEncodeH265ProfileEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265ProfileEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265ProfileEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( StdVideoH265ProfileIdc, seed, videoEncodeH265ProfileEXT.stdProfileIdc ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -96900,27 +91160,37 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265QpEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265QpEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH265QpEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265QpEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( qpI, qpP, qpB ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265QpEXT const & ) const = default; # else bool operator==( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -96935,25 +91205,6 @@ namespace VULKAN_HPP_NAMESPACE "struct wrapper is not a standard layout!" ); VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "VideoEncodeH265QpEXT is not nothrow_move_constructible!" ); - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const & videoEncodeH265QpEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH265QpEXT.qpI ); - VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH265QpEXT.qpP ); - VULKAN_HPP_HASH_COMBINE( int32_t, seed, videoEncodeH265QpEXT.qpB ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -96971,11 +91222,13 @@ namespace VULKAN_HPP_NAMESPACE uint32_t idrPeriod_ = {}, uint32_t consecutiveBFrameCount_ = {}, VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT rateControlStructure_ = - VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT::eUnknown ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT::eUnknown, + uint8_t subLayerCount_ = {} ) VULKAN_HPP_NOEXCEPT : gopFrameCount( gopFrameCount_ ) , idrPeriod( idrPeriod_ ) , consecutiveBFrameCount( consecutiveBFrameCount_ ) , rateControlStructure( rateControlStructure_ ) + , subLayerCount( subLayerCount_ ) {} VULKAN_HPP_CONSTEXPR @@ -97028,31 +91281,53 @@ namespace VULKAN_HPP_NAMESPACE rateControlStructure = rateControlStructure_; return *this; } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & + setSubLayerCount( uint8_t subLayerCount_ ) VULKAN_HPP_NOEXCEPT + { + subLayerCount = subLayerCount_; + return *this; + } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265RateControlInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265RateControlInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH265RateControlInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265RateControlInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, gopFrameCount, idrPeriod, consecutiveBFrameCount, rateControlStructure, subLayerCount ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265RateControlInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( gopFrameCount == rhs.gopFrameCount ) && - ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) && - ( rateControlStructure == rhs.rateControlStructure ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -97064,6 +91339,7 @@ namespace VULKAN_HPP_NAMESPACE uint32_t consecutiveBFrameCount = {}; VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT rateControlStructure = VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT::eUnknown; + uint8_t subLayerCount = {}; }; VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT ) == sizeof( VkVideoEncodeH265RateControlInfoEXT ), @@ -97079,30 +91355,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH265RateControlInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT const & - videoEncodeH265RateControlInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265RateControlInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265RateControlInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265RateControlInfoEXT.gopFrameCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265RateControlInfoEXT.idrPeriod ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265RateControlInfoEXT.consecutiveBFrameCount ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT, - seed, - videoEncodeH265RateControlInfoEXT.rateControlStructure ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -97226,31 +91478,57 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265RateControlLayerInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265RateControlLayerInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH265RateControlLayerInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265RateControlLayerInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + temporalId, + useInitialRcQp, + initialRcQp, + useMinQp, + minQp, + useMaxQp, + maxQp, + useMaxFrameSize, + maxFrameSize ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265RateControlLayerInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( temporalId == rhs.temporalId ) && - ( useInitialRcQp == rhs.useInitialRcQp ) && ( initialRcQp == rhs.initialRcQp ) && - ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) && - ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) && - ( maxFrameSize == rhs.maxFrameSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -97282,39 +91560,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH265RateControlLayerInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoEXT const & - videoEncodeH265RateControlLayerInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265RateControlLayerInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265RateControlLayerInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeH265RateControlLayerInfoEXT.temporalId ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265RateControlLayerInfoEXT.useInitialRcQp ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT, seed, videoEncodeH265RateControlLayerInfoEXT.initialRcQp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265RateControlLayerInfoEXT.useMinQp ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT, seed, videoEncodeH265RateControlLayerInfoEXT.minQp ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265RateControlLayerInfoEXT.useMaxQp ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT, seed, videoEncodeH265RateControlLayerInfoEXT.maxQp ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::Bool32, seed, videoEncodeH265RateControlLayerInfoEXT.useMaxFrameSize ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT, seed, videoEncodeH265RateControlLayerInfoEXT.maxFrameSize ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -97374,28 +91619,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH265SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pStdExtensionVersion ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265SessionCreateInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( pStdExtensionVersion == rhs.pStdExtensionVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -97419,29 +91676,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH265SessionCreateInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoEXT const & - videoEncodeH265SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265SessionCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265SessionCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoEncodeH265CreateFlagsEXT, seed, videoEncodeH265SessionCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::ExtensionProperties *, - seed, - videoEncodeH265SessionCreateInfoEXT.pStdExtensionVersion ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -97587,29 +91821,44 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH265SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vpsStdCount, pVpsStd, spsStdCount, pSpsStd, ppsStdCount, pPpsStd ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265SessionParametersAddInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vpsStdCount == rhs.vpsStdCount ) && - ( pVpsStd == rhs.pVpsStd ) && ( spsStdCount == rhs.spsStdCount ) && ( pSpsStd == rhs.pSpsStd ) && - ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -97638,34 +91887,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH265SessionParametersAddInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT const & - videoEncodeH265SessionParametersAddInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265SessionParametersAddInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265SessionParametersAddInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersAddInfoEXT.vpsStdCount ); - VULKAN_HPP_HASH_COMBINE( - const StdVideoH265VideoParameterSet *, seed, videoEncodeH265SessionParametersAddInfoEXT.pVpsStd ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersAddInfoEXT.spsStdCount ); - VULKAN_HPP_HASH_COMBINE( - const StdVideoH265SequenceParameterSet *, seed, videoEncodeH265SessionParametersAddInfoEXT.pSpsStd ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersAddInfoEXT.ppsStdCount ); - VULKAN_HPP_HASH_COMBINE( - const StdVideoH265PictureParameterSet *, seed, videoEncodeH265SessionParametersAddInfoEXT.pPpsStd ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -97747,29 +91968,42 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH265SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxVpsStdCount, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265SessionParametersCreateInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVpsStdCount == rhs.maxVpsStdCount ) && - ( maxSpsStdCount == rhs.maxSpsStdCount ) && ( maxPpsStdCount == rhs.maxPpsStdCount ) && - ( pParametersAddInfo == rhs.pParametersAddInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -97796,31 +92030,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH265SessionParametersCreateInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT const & - videoEncodeH265SessionParametersCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265SessionParametersCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265SessionParametersCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersCreateInfoEXT.maxVpsStdCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersCreateInfoEXT.maxSpsStdCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265SessionParametersCreateInfoEXT.maxPpsStdCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT *, - seed, - videoEncodeH265SessionParametersCreateInfoEXT.pParametersAddInfo ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -97920,29 +92129,43 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265VclFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265VclFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeH265VclFrameInfoEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeH265VclFrameInfoEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, pReferenceFinalLists, naluSliceEntryCount, pNaluSliceEntries, pCurrentPictureInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265VclFrameInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pReferenceFinalLists == rhs.pReferenceFinalLists ) && - ( naluSliceEntryCount == rhs.naluSliceEntryCount ) && ( pNaluSliceEntries == rhs.pNaluSliceEntries ) && - ( pCurrentPictureInfo == rhs.pCurrentPictureInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -97968,33 +92191,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeH265VclFrameInfoEXT; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265VclFrameInfoEXT const & videoEncodeH265VclFrameInfoEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeH265VclFrameInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeH265VclFrameInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT *, - seed, - videoEncodeH265VclFrameInfoEXT.pReferenceFinalLists ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeH265VclFrameInfoEXT.naluSliceEntryCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT *, - seed, - videoEncodeH265VclFrameInfoEXT.pNaluSliceEntries ); - VULKAN_HPP_HASH_COMBINE( - const StdVideoEncodeH265PictureInfo *, seed, videoEncodeH265VclFrameInfoEXT.pCurrentPictureInfo ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -98168,34 +92364,61 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + qualityLevel, + codedExtent, + dstBitstreamBuffer, + dstBitstreamBufferOffset, + dstBitstreamBufferMaxRange, + srcPictureResource, + pSetupReferenceSlot, + referenceSlotCount, + pReferenceSlots, + precedingExternallyEncodedBytes ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeInfoKHR const & ) const = default; # else bool operator==( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( qualityLevel == rhs.qualityLevel ) && ( codedExtent == rhs.codedExtent ) && - ( dstBitstreamBuffer == rhs.dstBitstreamBuffer ) && - ( dstBitstreamBufferOffset == rhs.dstBitstreamBufferOffset ) && - ( dstBitstreamBufferMaxRange == rhs.dstBitstreamBufferMaxRange ) && - ( srcPictureResource == rhs.srcPictureResource ) && ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) && - ( referenceSlotCount == rhs.referenceSlotCount ) && ( pReferenceSlots == rhs.pReferenceSlots ) && - ( precedingExternallyEncodedBytes == rhs.precedingExternallyEncodedBytes ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -98226,38 +92449,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR const & videoEncodeInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR, seed, videoEncodeInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeInfoKHR.qualityLevel ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoEncodeInfoKHR.codedExtent ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Buffer, seed, videoEncodeInfoKHR.dstBitstreamBuffer ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoEncodeInfoKHR.dstBitstreamBufferOffset ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DeviceSize, seed, videoEncodeInfoKHR.dstBitstreamBufferMaxRange ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR, seed, videoEncodeInfoKHR.srcPictureResource ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoEncodeInfoKHR.pSetupReferenceSlot ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeInfoKHR.referenceSlotCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR *, seed, videoEncodeInfoKHR.pReferenceSlots ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeInfoKHR.precedingExternallyEncodedBytes ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -98353,31 +92544,51 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeRateControlLayerInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeRateControlLayerInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeRateControlLayerInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeRateControlLayerInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + averageBitrate, + maxBitrate, + frameRateNumerator, + frameRateDenominator, + virtualBufferSizeInMs, + initialVirtualBufferSizeInMs ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeRateControlLayerInfoKHR const & ) const = default; # else bool operator==( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( averageBitrate == rhs.averageBitrate ) && - ( maxBitrate == rhs.maxBitrate ) && ( frameRateNumerator == rhs.frameRateNumerator ) && - ( frameRateDenominator == rhs.frameRateDenominator ) && - ( virtualBufferSizeInMs == rhs.virtualBufferSizeInMs ) && - ( initialVirtualBufferSizeInMs == rhs.initialVirtualBufferSizeInMs ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -98405,30 +92616,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeRateControlLayerInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR const & - videoEncodeRateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeRateControlLayerInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeRateControlLayerInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.averageBitrate ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.maxBitrate ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.frameRateNumerator ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.frameRateDenominator ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.virtualBufferSizeInMs ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoEncodeRateControlLayerInfoKHR.initialVirtualBufferSizeInMs ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -98528,29 +92715,42 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeRateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeRateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEncodeRateControlInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEncodeRateControlInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, rateControlMode, layerCount, pLayerConfigs ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeRateControlInfoKHR const & ) const = default; # else bool operator==( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( rateControlMode == rhs.rateControlMode ) && ( layerCount == rhs.layerCount ) && - ( pLayerConfigs == rhs.pLayerConfigs ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -98577,33 +92777,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEncodeRateControlInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR const & videoEncodeRateControlInfoKHR ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEncodeRateControlInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEncodeRateControlInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR, seed, videoEncodeRateControlInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR, - seed, - videoEncodeRateControlInfoKHR.rateControlMode ); - VULKAN_HPP_HASH_COMBINE( uint8_t, seed, videoEncodeRateControlInfoKHR.layerCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR *, - seed, - videoEncodeRateControlInfoKHR.pLayerConfigs ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -98650,27 +92823,39 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEndCodingInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEndCodingInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoEndCodingInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoEndCodingInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEndCodingInfoKHR const & ) const = default; # else bool operator==( VideoEndCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEndCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -98691,25 +92876,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoEndCodingInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR const & videoEndCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoEndCodingInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoEndCodingInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoEndCodingFlagsKHR, seed, videoEndCodingInfoKHR.flags ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -98741,27 +92907,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - operator VkVideoFormatPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoFormatPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoFormatPropertiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoFormatPropertiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, format ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoFormatPropertiesKHR const & ) const = default; # else bool operator==( VideoFormatPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoFormatPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -98783,25 +92959,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoFormatPropertiesKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR const & videoFormatPropertiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoFormatPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, videoFormatPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, videoFormatPropertiesKHR.format ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -98858,28 +93015,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoGetMemoryPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoGetMemoryPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoGetMemoryPropertiesKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoGetMemoryPropertiesKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryBindIndex, pMemoryRequirements ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoGetMemoryPropertiesKHR const & ) const = default; # else bool operator==( VideoGetMemoryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) && - ( pMemoryRequirements == rhs.pMemoryRequirements ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoGetMemoryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -98903,27 +93072,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoGetMemoryPropertiesKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR const & videoGetMemoryPropertiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoGetMemoryPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoGetMemoryPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoGetMemoryPropertiesKHR.memoryBindIndex ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::MemoryRequirements2 *, seed, videoGetMemoryPropertiesKHR.pMemoryRequirements ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -98972,27 +93120,39 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoQueueFamilyProperties2KHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoQueueFamilyProperties2KHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoQueueFamilyProperties2KHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoQueueFamilyProperties2KHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, videoCodecOperations ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoQueueFamilyProperties2KHR const & ) const = default; # else bool operator==( VideoQueueFamilyProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperations == rhs.videoCodecOperations ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoQueueFamilyProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -99015,26 +93175,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoQueueFamilyProperties2KHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoQueueFamilyProperties2KHR const & videoQueueFamilyProperties2KHR ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoQueueFamilyProperties2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( void *, seed, videoQueueFamilyProperties2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagsKHR, seed, videoQueueFamilyProperties2KHR.videoCodecOperations ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -99145,32 +93285,55 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoSessionCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoSessionCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoSessionCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoSessionCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + queueFamilyIndex, + flags, + pVideoProfile, + pictureFormat, + maxCodedExtent, + referencePicturesFormat, + maxReferencePicturesSlotsCount, + maxReferencePicturesActiveCount ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoSessionCreateInfoKHR const & ) const = default; # else bool operator==( VideoSessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) && - ( flags == rhs.flags ) && ( pVideoProfile == rhs.pVideoProfile ) && - ( pictureFormat == rhs.pictureFormat ) && ( maxCodedExtent == rhs.maxCodedExtent ) && - ( referencePicturesFormat == rhs.referencePicturesFormat ) && - ( maxReferencePicturesSlotsCount == rhs.maxReferencePicturesSlotsCount ) && - ( maxReferencePicturesActiveCount == rhs.maxReferencePicturesActiveCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoSessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -99199,33 +93362,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoSessionCreateInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & videoSessionCreateInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoSessionCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoSessionCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoSessionCreateInfoKHR.queueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoSessionCreateFlagsKHR, seed, videoSessionCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::VideoProfileKHR *, seed, videoSessionCreateInfoKHR.pVideoProfile ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, videoSessionCreateInfoKHR.pictureFormat ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Extent2D, seed, videoSessionCreateInfoKHR.maxCodedExtent ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Format, seed, videoSessionCreateInfoKHR.referencePicturesFormat ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoSessionCreateInfoKHR.maxReferencePicturesSlotsCount ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoSessionCreateInfoKHR.maxReferencePicturesActiveCount ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -99285,29 +93421,40 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoSessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoSessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoSessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoSessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, videoSessionParametersTemplate, videoSession ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoSessionParametersCreateInfoKHR const & ) const = default; # else bool operator==( VideoSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( videoSessionParametersTemplate == rhs.videoSessionParametersTemplate ) && - ( videoSession == rhs.videoSession ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -99331,29 +93478,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoSessionParametersCreateInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & - videoSessionParametersCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoSessionParametersCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoSessionParametersCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, - seed, - videoSessionParametersCreateInfoKHR.videoSessionParametersTemplate ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::VideoSessionKHR, seed, videoSessionParametersCreateInfoKHR.videoSession ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -99403,27 +93527,37 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoSessionParametersUpdateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkVideoSessionParametersUpdateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkVideoSessionParametersUpdateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkVideoSessionParametersUpdateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, updateSequenceCount ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoSessionParametersUpdateInfoKHR const & ) const = default; # else bool operator==( VideoSessionParametersUpdateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( updateSequenceCount == rhs.updateSequenceCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoSessionParametersUpdateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -99446,25 +93580,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = VideoSessionParametersUpdateInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR const & - videoSessionParametersUpdateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, videoSessionParametersUpdateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, videoSessionParametersUpdateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, videoSessionParametersUpdateInfoKHR.updateSequenceCount ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_USE_PLATFORM_WAYLAND_KHR ) @@ -99527,28 +93642,41 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkWaylandSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkWaylandSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkWaylandSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkWaylandSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, display, surface ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( WaylandSurfaceCreateInfoKHR const & ) const = default; # else bool operator==( WaylandSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( display == rhs.display ) && - ( surface == rhs.surface ); + return this->reflect() == rhs.reflect(); } bool operator!=( WaylandSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -99573,28 +93701,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = WaylandSurfaceCreateInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & waylandSurfaceCreateInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, waylandSurfaceCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, waylandSurfaceCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateFlagsKHR, seed, waylandSurfaceCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( struct wl_display *, seed, waylandSurfaceCreateInfoKHR.display ); - VULKAN_HPP_HASH_COMBINE( struct wl_surface *, seed, waylandSurfaceCreateInfoKHR.surface ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ #if defined( VK_USE_PLATFORM_WIN32_KHR ) @@ -99805,30 +93911,53 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkWin32KeyedMutexAcquireReleaseInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkWin32KeyedMutexAcquireReleaseInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkWin32KeyedMutexAcquireReleaseInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkWin32KeyedMutexAcquireReleaseInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + acquireCount, + pAcquireSyncs, + pAcquireKeys, + pAcquireTimeouts, + releaseCount, + pReleaseSyncs, + pReleaseKeys ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Win32KeyedMutexAcquireReleaseInfoKHR const & ) const = default; # else bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireCount == rhs.acquireCount ) && - ( pAcquireSyncs == rhs.pAcquireSyncs ) && ( pAcquireKeys == rhs.pAcquireKeys ) && - ( pAcquireTimeouts == rhs.pAcquireTimeouts ) && ( releaseCount == rhs.releaseCount ) && - ( pReleaseSyncs == rhs.pReleaseSyncs ) && ( pReleaseKeys == rhs.pReleaseKeys ); + return this->reflect() == rhs.reflect(); } bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -99857,33 +93986,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = Win32KeyedMutexAcquireReleaseInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR const & - win32KeyedMutexAcquireReleaseInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, win32KeyedMutexAcquireReleaseInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, win32KeyedMutexAcquireReleaseInfoKHR.acquireCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::DeviceMemory *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireSyncs ); - VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireKeys ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireTimeouts ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, win32KeyedMutexAcquireReleaseInfoKHR.releaseCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::DeviceMemory *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseSyncs ); - VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseKeys ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #if defined( VK_USE_PLATFORM_WIN32_KHR ) @@ -100095,31 +94197,53 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkWin32KeyedMutexAcquireReleaseInfoNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkWin32KeyedMutexAcquireReleaseInfoNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkWin32KeyedMutexAcquireReleaseInfoNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkWin32KeyedMutexAcquireReleaseInfoNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + acquireCount, + pAcquireSyncs, + pAcquireKeys, + pAcquireTimeoutMilliseconds, + releaseCount, + pReleaseSyncs, + pReleaseKeys ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Win32KeyedMutexAcquireReleaseInfoNV const & ) const = default; # else bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireCount == rhs.acquireCount ) && - ( pAcquireSyncs == rhs.pAcquireSyncs ) && ( pAcquireKeys == rhs.pAcquireKeys ) && - ( pAcquireTimeoutMilliseconds == rhs.pAcquireTimeoutMilliseconds ) && - ( releaseCount == rhs.releaseCount ) && ( pReleaseSyncs == rhs.pReleaseSyncs ) && - ( pReleaseKeys == rhs.pReleaseKeys ); + return this->reflect() == rhs.reflect(); } bool operator!=( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -100148,33 +94272,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = Win32KeyedMutexAcquireReleaseInfoNV; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV const & - win32KeyedMutexAcquireReleaseInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, win32KeyedMutexAcquireReleaseInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, win32KeyedMutexAcquireReleaseInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, win32KeyedMutexAcquireReleaseInfoNV.acquireCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::DeviceMemory *, seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireSyncs ); - VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireKeys ); - VULKAN_HPP_HASH_COMBINE( const uint32_t *, seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireTimeoutMilliseconds ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, win32KeyedMutexAcquireReleaseInfoNV.releaseCount ); - VULKAN_HPP_HASH_COMBINE( - const VULKAN_HPP_NAMESPACE::DeviceMemory *, seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseSyncs ); - VULKAN_HPP_HASH_COMBINE( const uint64_t *, seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseKeys ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #if defined( VK_USE_PLATFORM_WIN32_KHR ) @@ -100237,28 +94334,41 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkWin32SurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkWin32SurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkWin32SurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkWin32SurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, hinstance, hwnd ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Win32SurfaceCreateInfoKHR const & ) const = default; # else bool operator==( Win32SurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( hinstance == rhs.hinstance ) && ( hwnd == rhs.hwnd ); + return this->reflect() == rhs.reflect(); } bool operator!=( Win32SurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -100282,27 +94392,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = Win32SurfaceCreateInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & win32SurfaceCreateInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, win32SurfaceCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, win32SurfaceCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateFlagsKHR, seed, win32SurfaceCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( HINSTANCE, seed, win32SurfaceCreateInfoKHR.hinstance ); - VULKAN_HPP_HASH_COMBINE( HWND, seed, win32SurfaceCreateInfoKHR.hwnd ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct WriteDescriptorSet @@ -100476,31 +94565,55 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkWriteDescriptorSet const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkWriteDescriptorSet const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkWriteDescriptorSet &() VULKAN_HPP_NOEXCEPT + explicit operator VkWriteDescriptorSet &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + dstSet, + dstBinding, + dstArrayElement, + descriptorCount, + descriptorType, + pImageInfo, + pBufferInfo, + pTexelBufferView ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( WriteDescriptorSet const & ) const = default; #else bool operator==( WriteDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dstSet == rhs.dstSet ) && - ( dstBinding == rhs.dstBinding ) && ( dstArrayElement == rhs.dstArrayElement ) && - ( descriptorCount == rhs.descriptorCount ) && ( descriptorType == rhs.descriptorType ) && - ( pImageInfo == rhs.pImageInfo ) && ( pBufferInfo == rhs.pBufferInfo ) && - ( pTexelBufferView == rhs.pTexelBufferView ); + return this->reflect() == rhs.reflect(); } bool operator!=( WriteDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -100529,31 +94642,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = WriteDescriptorSet; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t - operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSet const & writeDescriptorSet ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, writeDescriptorSet.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSet.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorSet, seed, writeDescriptorSet.dstSet ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSet.dstBinding ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSet.dstArrayElement ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSet.descriptorCount ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::DescriptorType, seed, writeDescriptorSet.descriptorType ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::DescriptorImageInfo *, seed, writeDescriptorSet.pImageInfo ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::DescriptorBufferInfo *, seed, writeDescriptorSet.pBufferInfo ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::BufferView *, seed, writeDescriptorSet.pTexelBufferView ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct WriteDescriptorSetAccelerationStructureKHR { using NativeType = VkWriteDescriptorSetAccelerationStructureKHR; @@ -100633,29 +94721,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkWriteDescriptorSetAccelerationStructureKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkWriteDescriptorSetAccelerationStructureKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkWriteDescriptorSetAccelerationStructureKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkWriteDescriptorSetAccelerationStructureKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( WriteDescriptorSetAccelerationStructureKHR const & ) const = default; #else bool operator==( WriteDescriptorSetAccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( accelerationStructureCount == rhs.accelerationStructureCount ) && - ( pAccelerationStructures == rhs.pAccelerationStructures ); + return this->reflect() == rhs.reflect(); } bool operator!=( WriteDescriptorSetAccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -100681,28 +94780,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = WriteDescriptorSetAccelerationStructureKHR; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR const & - writeDescriptorSetAccelerationStructureKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, writeDescriptorSetAccelerationStructureKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSetAccelerationStructureKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSetAccelerationStructureKHR.accelerationStructureCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *, - seed, - writeDescriptorSetAccelerationStructureKHR.pAccelerationStructures ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct WriteDescriptorSetAccelerationStructureNV { using NativeType = VkWriteDescriptorSetAccelerationStructureNV; @@ -100782,29 +94859,40 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkWriteDescriptorSetAccelerationStructureNV const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkWriteDescriptorSetAccelerationStructureNV const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkWriteDescriptorSetAccelerationStructureNV &() VULKAN_HPP_NOEXCEPT + explicit operator VkWriteDescriptorSetAccelerationStructureNV &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( WriteDescriptorSetAccelerationStructureNV const & ) const = default; #else bool operator==( WriteDescriptorSetAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( accelerationStructureCount == rhs.accelerationStructureCount ) && - ( pAccelerationStructures == rhs.pAccelerationStructures ); + return this->reflect() == rhs.reflect(); } bool operator!=( WriteDescriptorSetAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -100830,28 +94918,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = WriteDescriptorSetAccelerationStructureNV; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV const & - writeDescriptorSetAccelerationStructureNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( - VULKAN_HPP_NAMESPACE::StructureType, seed, writeDescriptorSetAccelerationStructureNV.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSetAccelerationStructureNV.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSetAccelerationStructureNV.accelerationStructureCount ); - VULKAN_HPP_HASH_COMBINE( const VULKAN_HPP_NAMESPACE::AccelerationStructureNV *, - seed, - writeDescriptorSetAccelerationStructureNV.pAccelerationStructures ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ struct WriteDescriptorSetInlineUniformBlockEXT { using NativeType = VkWriteDescriptorSetInlineUniformBlockEXT; @@ -100927,27 +94993,38 @@ namespace VULKAN_HPP_NAMESPACE # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkWriteDescriptorSetInlineUniformBlockEXT const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkWriteDescriptorSetInlineUniformBlockEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkWriteDescriptorSetInlineUniformBlockEXT &() VULKAN_HPP_NOEXCEPT + explicit operator VkWriteDescriptorSetInlineUniformBlockEXT &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std:: + tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dataSize, pData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( WriteDescriptorSetInlineUniformBlockEXT const & ) const = default; #else bool operator==( WriteDescriptorSetInlineUniformBlockEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); + return this->reflect() == rhs.reflect(); } bool operator!=( WriteDescriptorSetInlineUniformBlockEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -100973,25 +95050,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = WriteDescriptorSetInlineUniformBlockEXT; }; -} // namespace VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlockEXT const & - writeDescriptorSetInlineUniformBlockEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, writeDescriptorSetInlineUniformBlockEXT.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSetInlineUniformBlockEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( uint32_t, seed, writeDescriptorSetInlineUniformBlockEXT.dataSize ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, writeDescriptorSetInlineUniformBlockEXT.pData ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #if defined( VK_USE_PLATFORM_XCB_KHR ) struct XcbSurfaceCreateInfoKHR { @@ -101052,28 +95110,41 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkXcbSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkXcbSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkXcbSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkXcbSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, connection, window ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( XcbSurfaceCreateInfoKHR const & ) const = default; # else bool operator==( XcbSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( connection == rhs.connection ) && ( memcmp( &window, &rhs.window, sizeof( xcb_window_t ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( XcbSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -101097,27 +95168,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = XcbSurfaceCreateInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & xcbSurfaceCreateInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, xcbSurfaceCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, xcbSurfaceCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateFlagsKHR, seed, xcbSurfaceCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( xcb_connection_t *, seed, xcbSurfaceCreateInfoKHR.connection ); - VULKAN_HPP_HASH_COMBINE( xcb_window_t, seed, xcbSurfaceCreateInfoKHR.window ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_XCB_KHR*/ #if defined( VK_USE_PLATFORM_XLIB_KHR ) @@ -101179,28 +95229,41 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkXlibSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + explicit operator VkXlibSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } - operator VkXlibSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + explicit operator VkXlibSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, dpy, window ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( XlibSurfaceCreateInfoKHR const & ) const = default; # else bool operator==( XlibSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dpy == rhs.dpy ) && - ( memcmp( &window, &rhs.window, sizeof( Window ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( XlibSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -101224,27 +95287,6 @@ namespace VULKAN_HPP_NAMESPACE { using Type = XlibSurfaceCreateInfoKHR; }; - -} // VULKAN_HPP_NAMESPACE - -template <> -struct std::hash -{ - std::size_t operator()( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & xlibSurfaceCreateInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::StructureType, seed, xlibSurfaceCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( const void *, seed, xlibSurfaceCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateFlagsKHR, seed, xlibSurfaceCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( Display *, seed, xlibSurfaceCreateInfoKHR.dpy ); - VULKAN_HPP_HASH_COMBINE( Window, seed, xlibSurfaceCreateInfoKHR.window ); - return seed; - } -}; - -namespace VULKAN_HPP_NAMESPACE -{ #endif /*VK_USE_PLATFORM_XLIB_KHR*/ } // namespace VULKAN_HPP_NAMESPACE diff --git a/registry/generator.py b/registry/generator.py index ad07c38..0c2a408 100644 --- a/registry/generator.py +++ b/registry/generator.py @@ -55,10 +55,13 @@ def regSortCategoryKey(feature): Sorts by category of the feature name string: - Core API features (those defined with a `` tag) + - (sort VKSC after VK) - ARB/KHR/OES (Khronos extensions) - other (EXT/vendor extensions)""" if feature.elem.tag == 'feature': + if feature.name.startswith('VKSC'): + return 0.5 return 0 if (feature.category == 'ARB' or feature.category == 'KHR' @@ -1063,7 +1066,8 @@ class OutputGenerator: return False info = self.registry.typedict.get(structname) - assert(info is not None) + if info is None: + self.logMsg('error', f'isStructAlwaysValid({structname}) - structure not found in typedict') members = info.getMembers() diff --git a/registry/genvk.py b/registry/genvk.py index 95dc0d4..150b348 100755 --- a/registry/genvk.py +++ b/registry/genvk.py @@ -511,6 +511,83 @@ def makeGenOpts(args): misracppstyle = misracppstyle) ] + # Video header target - combines all video extension dependencies into a + # single header, at present. + genOpts['vk_video.h'] = [ + COutputGenerator, + CGeneratorOptions( + conventions = conventions, + filename = 'vk_video.h', + directory = directory, + genpath = None, + apiname = 'vulkan', + profile = None, + versions = None, + emitversions = None, + defaultExtensions = defaultExtensions, + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = '', + apientry = '', + apientryp = '', + alignFuncParam = 48, + misracstyle = misracstyle, + misracppstyle = misracppstyle) + ] + + # Video extension 'Std' interfaces, each in its own header files + # These are not Vulkan extensions, or a part of the Vulkan API at all, + # but are treated in a similar fashion for generation purposes. + # + # Each element of the videoStd[] array is an 'extension' name defining + # an iterface, and is also the basis for the generated header file name. + + videoStd = [ + 'vulkan_video_codecs_common', + 'vulkan_video_codec_h264std', + 'vulkan_video_codec_h264std_decode', + 'vulkan_video_codec_h264std_encode', + 'vulkan_video_codec_h265std', + 'vulkan_video_codec_h265std_decode', + 'vulkan_video_codec_h265std_encode', + ] + + addExtensionRE = makeREstring(videoStd) + for codec in videoStd: + headername = f'{codec}.h' + + # Consider all of the codecs 'extensions', but only emit this one + emitExtensionRE = makeREstring([codec]) + + opts = CGeneratorOptions( + conventions = conventions, + filename = headername, + directory = directory, + genpath = None, + apiname = defaultAPIName, + profile = None, + versions = None, + emitversions = None, + defaultExtensions = None, + addExtensions = addExtensionRE, + removeExtensions = None, + emitExtensions = emitExtensionRE, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = False, + protectFile = protectFile, + protectFeature = False, + alignFuncParam = 48, + ) + + genOpts[headername] = [ COutputGenerator, opts ] + # Unused - vulkan11.h target. # It is possible to generate a header with just the Vulkan 1.0 + # extension interfaces defined, but since the promoted KHR extensions diff --git a/registry/reg.py b/registry/reg.py index 6eec554..aeef363 100644 --- a/registry/reg.py +++ b/registry/reg.py @@ -104,13 +104,14 @@ def stripNonmatchingAPIs(tree, apiName, actuallyDelete = True): for child in parent.findall('*'): api = child.get('api') - if api: - if not apiNameMatch(apiName, api): - if actuallyDelete: - parent.remove(child) - else: + + if apiNameMatch(apiName, api): # Add child to the queue stack.append(child) + elif not apiNameMatch(apiName, api): + # Child does not match requested api. Remove it. + if actuallyDelete: + parent.remove(child) class BaseInfo: @@ -403,22 +404,15 @@ class Registry: - infoName - 'type' / 'group' / 'enum' / 'command' / 'feature' / 'extension' / 'spirvextension' / 'spirvcapability' / 'format' - dictionary - self.{type|group|enum|cmd|api|ext|format|spirvext|spirvcap}dict - If the Element has an 'api' attribute, the dictionary key is the - tuple (name,api). If not, the key is the name. 'name' is an - attribute of the Element""" + The dictionary key is the element 'name' attribute.""" + # self.gen.logMsg('diag', 'Adding ElementInfo.required =', # info.required, 'name =', elem.get('name')) - api = elem.get('api') - if api: - key = (elem.get('name'), api) - else: - key = elem.get('name') + key = elem.get('name') if key in dictionary: if not dictionary[key].compareElem(info, infoName): self.gen.logMsg('warn', 'Attempt to redefine', key, '(this should not happen)') - else: - True else: dictionary[key] = info @@ -459,7 +453,7 @@ class Registry: # overlapping api attributes, or where one element has an api # attribute and the other does not. - stripNonmatchingAPIs(self.reg, self.genOpts.apiname) + stripNonmatchingAPIs(self.reg, self.genOpts.apiname, actuallyDelete = True) # Create dictionary of registry types from toplevel tags # and add 'name' attribute to each tag (where missing) @@ -720,6 +714,7 @@ class Registry: - required - boolean (to tag features as required or not) """ self.gen.logMsg('diag', 'tagging type:', typename, '-> required =', required) + # Get TypeInfo object for tag corresponding to typename typeinfo = self.lookupElementInfo(typename, self.typedict) if typeinfo is not None: @@ -774,20 +769,18 @@ class Registry: - enumname - name of enum - required - boolean (to tag features as required or not)""" - self.gen.logMsg('diag', 'tagging enum:', enumname, '-> required =', required) + self.gen.logMsg('diag', 'markEnumRequired: tagging enum:', enumname, '-> required =', required) enum = self.lookupElementInfo(enumname, self.enumdict) if enum is not None: # If the enum is part of a group, and is being removed, then - # look it up in that tag and remove it there, so that it - # is not visible to generators (which traverse the tag - # elements themselves). - # This is not the most robust way of doing this, since a removed - # enum that is later required again will no longer have a group - # element, but it makes the change non-intrusive on generator - # code. - if required is False: + # look it up in that tag and remove the Element there, + # so that it is not visible to generators (which traverse the + # tag elements rather than using the dictionaries). + if not required: groupName = enum.elem.get('extends') if groupName is not None: + self.gen.logMsg('diag', f'markEnumRequired: Removing extending enum {enum.elem.get("name")}') + # Look up the Info with matching groupName if groupName in self.groupdict: gi = self.groupdict[groupName] @@ -796,23 +789,42 @@ class Registry: # Remove copy of this enum from the group gi.elem.remove(gienum) else: - self.gen.logMsg('warn', 'Cannot remove enum', + self.gen.logMsg('warn', 'markEnumRequired: Cannot remove enum', enumname, 'not found in group', groupName) else: - self.gen.logMsg('warn', 'Cannot remove enum', + self.gen.logMsg('warn', 'markEnumRequired: Cannot remove enum', enumname, 'from nonexistent group', groupName) + else: + # This enum is not an extending enum. + # The XML tree must be searched for all that + # might have it, so we know the parent to delete from. + + enumName = enum.elem.get('name') + + self.gen.logMsg('diag', f'markEnumRequired: Removing non-extending enum {enumName}') + + count = 0 + for enums in self.reg.findall('enums'): + for thisEnum in enums.findall('enum'): + if thisEnum.get('name') == enumName: + # Actually remove it + count = count + 1 + enums.remove(thisEnum) + + if count == 0: + self.gen.logMsg('warn', f'markEnumRequired: {enumName}) not found in any tag') enum.required = required # Tag enum dependencies in 'alias' attribute as required depname = enum.elem.get('alias') if depname: - self.gen.logMsg('diag', 'Generating dependent enum', + self.gen.logMsg('diag', 'markEnumRequired: Generating dependent enum', depname, 'for alias', enumname, 'required =', enum.required) self.markEnumRequired(depname, required) else: - self.gen.logMsg('warn', 'enum:', enumname, 'IS NOT DEFINED') + self.gen.logMsg('warn', f'markEnumRequired: {enumname} IS NOT DEFINED') def markCmdRequired(self, cmdname, required): """Mark a command as required or not. @@ -869,6 +881,7 @@ class Registry: self.markTypeRequired(typeElem.get('name'), required) for enumElem in feature.findall('enum'): self.markEnumRequired(enumElem.get('name'), required) + for cmdElem in feature.findall('command'): self.markCmdRequired(cmdElem.get('name'), required) @@ -1009,11 +1022,11 @@ class Registry: else: self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename)) - def requireAndRemoveFeatures(self, interface, featurename, api, profile): - """Process `` and `` tags for a `` or ``. + def requireFeatures(self, interface, featurename, api, profile): + """Process `` tags for a `` or ``. - interface - Element for `` or ``, containing - `` and `` tags + `` tags - featurename - name of the feature - api - string specifying API name being generated - profile - string specifying API profile being generated""" @@ -1023,6 +1036,15 @@ class Registry: if matchAPIProfile(api, profile, feature): self.markRequired(featurename, feature, True) + def removeFeatures(self, interface, featurename, api, profile): + """Process `` tags for a `` or ``. + + - interface - Element for `` or ``, containing + `` tags + - featurename - name of the feature + - api - string specifying API name being generated + - profile - string specifying API profile being generated""" + # marks things that are removed by this version/profile for feature in interface.findall('remove'): if matchAPIProfile(api, profile, feature): @@ -1038,6 +1060,7 @@ class Registry: if v.get('struct'): self.typedict[v.get('struct')].additionalValidity.append(copy.deepcopy(v)) + def removeAdditionalValidity(self, interface, api, profile): # Loop over all usage inside all tags. for feature in interface.findall('remove'): if matchAPIProfile(api, profile, feature): @@ -1165,7 +1188,8 @@ class Registry: if extname is not None: # 'supported' attribute was injected when the element was # moved into the group in Registry.parseTree() - if self.genOpts.defaultExtensions == elem.get('supported'): + supported_list = elem.get('supported').split(",") + if self.genOpts.defaultExtensions in supported_list: required = True elif re.match(self.genOpts.addExtensions, extname) is not None: required = True @@ -1353,7 +1377,7 @@ class Registry: # Get all matching extensions, in order by their extension number, # and add to the list of features. - # Start with extensions tagged with 'api' pattern matching the API + # Start with extensions whose 'supported' attributes match the API # being generated. Add extensions matching the pattern specified in # regExtensions, then remove extensions matching the pattern # specified in regRemoveExtensions @@ -1435,22 +1459,25 @@ class Registry: self.genOpts.sortProcedure(features) # print('sortProcedure ->', [f.name for f in features]) - # Pass 1: loop over requested API versions and extensions tagging + # Passes 1+2: loop over requested API versions and extensions tagging # types/commands/features as required (in an block) or no - # longer required (in an block). It is possible to remove - # a feature in one version and restore it later by requiring it in - # a later version. + # longer required (in an block). s are processed + # after all s, so removals win. # If a profile other than 'None' is being generated, it must # match the profile attribute (if any) of the and # tags. self.gen.logMsg('diag', 'PASS 1: TAG FEATURES') for f in features: - self.gen.logMsg('diag', 'PASS 1: Tagging required and removed features for', - f.name) + self.gen.logMsg('diag', 'PASS 1: Tagging required and features for', f.name) self.fillFeatureDictionary(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile) - self.requireAndRemoveFeatures(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile) + self.requireFeatures(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile) self.assignAdditionalValidity(f.elem, self.genOpts.apiname, self.genOpts.profile) + for f in features: + self.gen.logMsg('diag', 'PASS 2: Tagging removed features for', f.name) + self.removeFeatures(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile) + self.removeAdditionalValidity(f.elem, self.genOpts.apiname, self.genOpts.profile) + # Now, strip references to APIs that are not required. # At present such references may occur in: # Structs in 'structextends' attributes @@ -1466,17 +1493,17 @@ class Registry: # # - # Pass 2: loop over specified API versions and extensions printing + # Pass 3: loop over specified API versions and extensions printing # declarations for required things which have not already been # generated. - self.gen.logMsg('diag', 'PASS 2: GENERATE INTERFACES FOR FEATURES') + self.gen.logMsg('diag', 'PASS 3: GENERATE INTERFACES FOR FEATURES') self.gen.beginFile(self.genOpts) for f in features: - self.gen.logMsg('diag', 'PASS 2: Generating interface for', + self.gen.logMsg('diag', 'PASS 3: Generating interface for', f.name) emit = self.emitFeatures = f.emit if not emit: - self.gen.logMsg('diag', 'PASS 2: NOT declaring feature', + self.gen.logMsg('diag', 'PASS 3: NOT declaring feature', f.elem.get('name'), 'because it is not tagged for emission') # Generate the interface (or just tag its elements as having been # emitted, if they have not been). diff --git a/registry/validusage.json b/registry/validusage.json index 856fa2a..29de1ea 100644 --- a/registry/validusage.json +++ b/registry/validusage.json @@ -1,9 +1,9 @@ { "version info": { "schema version": 2, - "api version": "1.2.202", - "comment": "from git branch: github-main commit: 48b76697118c275337e49836259f0571b3410d84", - "date": "2021-12-07 08:44:26Z" + "api version": "1.2.203", + "comment": "from git branch: github-main commit: ac23aa229fd9b8ea06aa99cf07b79cdc15af406f", + "date": "2021-12-20 11:55:32Z" }, "validation": { "vkGetInstanceProcAddr": { @@ -238,7 +238,7 @@ }, { "vuid": "VUID-VkPhysicalDeviceProperties2-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceAccelerationStructurePropertiesKHR, VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceCooperativeMatrixPropertiesNV, VkPhysicalDeviceCustomBorderColorPropertiesEXT, VkPhysicalDeviceDepthStencilResolveProperties, VkPhysicalDeviceDescriptorIndexingProperties, VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDriverProperties, VkPhysicalDeviceDrmPropertiesEXT, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceFloatControlsProperties, VkPhysicalDeviceFragmentDensityMap2PropertiesEXT, VkPhysicalDeviceFragmentDensityMapPropertiesEXT, VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV, VkPhysicalDeviceFragmentShadingRatePropertiesKHR, VkPhysicalDeviceIDProperties, VkPhysicalDeviceInlineUniformBlockPropertiesEXT, VkPhysicalDeviceLineRasterizationPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMaintenance4PropertiesKHR, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiDrawPropertiesEXT, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePerformanceQueryPropertiesKHR, VkPhysicalDevicePointClippingProperties, VkPhysicalDevicePortabilitySubsetPropertiesKHR, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDeviceProvokingVertexPropertiesEXT, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceRayTracingPipelinePropertiesKHR, VkPhysicalDeviceRayTracingPropertiesNV, VkPhysicalDeviceRobustness2PropertiesEXT, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxProperties, VkPhysicalDeviceShaderCoreProperties2AMD, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV, VkPhysicalDeviceShadingRateImagePropertiesNV, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceSubgroupSizeControlPropertiesEXT, VkPhysicalDeviceSubpassShadingPropertiesHUAWEI, VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT, VkPhysicalDeviceTimelineSemaphoreProperties, VkPhysicalDeviceTransformFeedbackPropertiesEXT, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT, VkPhysicalDeviceVulkan11Properties, or VkPhysicalDeviceVulkan12Properties" + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceAccelerationStructurePropertiesKHR, VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceCooperativeMatrixPropertiesNV, VkPhysicalDeviceCustomBorderColorPropertiesEXT, VkPhysicalDeviceDepthStencilResolveProperties, VkPhysicalDeviceDescriptorIndexingProperties, VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDriverProperties, VkPhysicalDeviceDrmPropertiesEXT, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceFloatControlsProperties, VkPhysicalDeviceFragmentDensityMap2PropertiesEXT, VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, VkPhysicalDeviceFragmentDensityMapPropertiesEXT, VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV, VkPhysicalDeviceFragmentShadingRatePropertiesKHR, VkPhysicalDeviceIDProperties, VkPhysicalDeviceInlineUniformBlockPropertiesEXT, VkPhysicalDeviceLineRasterizationPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMaintenance4PropertiesKHR, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiDrawPropertiesEXT, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePerformanceQueryPropertiesKHR, VkPhysicalDevicePointClippingProperties, VkPhysicalDevicePortabilitySubsetPropertiesKHR, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDeviceProvokingVertexPropertiesEXT, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceRayTracingPipelinePropertiesKHR, VkPhysicalDeviceRayTracingPropertiesNV, VkPhysicalDeviceRobustness2PropertiesEXT, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxProperties, VkPhysicalDeviceShaderCoreProperties2AMD, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV, VkPhysicalDeviceShadingRateImagePropertiesNV, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceSubgroupSizeControlPropertiesEXT, VkPhysicalDeviceSubpassShadingPropertiesHUAWEI, VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT, VkPhysicalDeviceTimelineSemaphoreProperties, VkPhysicalDeviceTransformFeedbackPropertiesEXT, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT, VkPhysicalDeviceVulkan11Properties, or VkPhysicalDeviceVulkan12Properties" }, { "vuid": "VUID-VkPhysicalDeviceProperties2-sType-unique", @@ -342,7 +342,7 @@ }, { "vuid": "VUID-VkQueueFamilyProperties2-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkQueueFamilyCheckpointProperties2NV, VkQueueFamilyCheckpointPropertiesNV, VkQueueFamilyGlobalPriorityPropertiesEXT, or VkVideoQueueFamilyProperties2KHR" + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkQueueFamilyCheckpointProperties2NV, VkQueueFamilyCheckpointPropertiesNV, VkQueueFamilyGlobalPriorityPropertiesEXT, VkQueueFamilyQueryResultStatusProperties2KHR, or VkVideoQueueFamilyProperties2KHR" }, { "vuid": "VUID-VkQueueFamilyProperties2-sType-unique", @@ -529,44 +529,44 @@ ], "(VK_VERSION_1_2)+(VK_KHR_shader_draw_parameters)": [ { - "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensions-04476", - "text": " If ppEnabledExtensions contains \"VK_KHR_shader_draw_parameters\" and the pNext chain includes a VkPhysicalDeviceVulkan11Features structure, then VkPhysicalDeviceVulkan11Features::shaderDrawParameters must be VK_TRUE" + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-04476", + "text": " If ppEnabledExtensionNames contains \"VK_KHR_shader_draw_parameters\" and the pNext chain includes a VkPhysicalDeviceVulkan11Features structure, then VkPhysicalDeviceVulkan11Features::shaderDrawParameters must be VK_TRUE" } ], "(VK_VERSION_1_2)+(VK_KHR_draw_indirect_count)": [ { - "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensions-02831", - "text": " If ppEnabledExtensions contains \"VK_KHR_draw_indirect_count\" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::drawIndirectCount must be VK_TRUE" + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-02831", + "text": " If ppEnabledExtensionNames contains \"VK_KHR_draw_indirect_count\" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::drawIndirectCount must be VK_TRUE" } ], "(VK_VERSION_1_2)+(VK_KHR_sampler_mirror_clamp_to_edge)": [ { - "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensions-02832", - "text": " If ppEnabledExtensions contains \"VK_KHR_sampler_mirror_clamp_to_edge\" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::samplerMirrorClampToEdge must be VK_TRUE" + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-02832", + "text": " If ppEnabledExtensionNames contains \"VK_KHR_sampler_mirror_clamp_to_edge\" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::samplerMirrorClampToEdge must be VK_TRUE" } ], "(VK_VERSION_1_2)+(VK_EXT_descriptor_indexing)": [ { - "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensions-02833", - "text": " If ppEnabledExtensions contains \"VK_EXT_descriptor_indexing\" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::descriptorIndexing must be VK_TRUE" + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-02833", + "text": " If ppEnabledExtensionNames contains \"VK_EXT_descriptor_indexing\" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::descriptorIndexing must be VK_TRUE" } ], "(VK_VERSION_1_2)+(VK_EXT_sampler_filter_minmax)": [ { - "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensions-02834", - "text": " If ppEnabledExtensions contains \"VK_EXT_sampler_filter_minmax\" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::samplerFilterMinmax must be VK_TRUE" + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-02834", + "text": " If ppEnabledExtensionNames contains \"VK_EXT_sampler_filter_minmax\" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::samplerFilterMinmax must be VK_TRUE" } ], "(VK_VERSION_1_2)+(VK_EXT_shader_viewport_index_layer)": [ { - "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensions-02835", - "text": " If ppEnabledExtensions contains \"VK_EXT_shader_viewport_index_layer\" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::shaderOutputViewportIndex and VkPhysicalDeviceVulkan12Features::shaderOutputLayer must both be VK_TRUE" + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-02835", + "text": " If ppEnabledExtensionNames contains \"VK_EXT_shader_viewport_index_layer\" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::shaderOutputViewportIndex and VkPhysicalDeviceVulkan12Features::shaderOutputLayer must both be VK_TRUE" } ], "(VK_KHR_portability_subset)": [ { "vuid": "VUID-VkDeviceCreateInfo-pProperties-04451", - "text": " If the VK_KHR_portability_subset extension is included in pProperties of vkEnumerateDeviceExtensionProperties, ppEnabledExtensions must include \"VK_KHR_portability_subset\"" + "text": " If the VK_KHR_portability_subset extension is included in pProperties of vkEnumerateDeviceExtensionProperties, ppEnabledExtensionNames must include \"VK_KHR_portability_subset\"" } ], "(VK_KHR_fragment_shading_rate,VK_NV_shading_rate_image)": [ @@ -626,7 +626,7 @@ }, { "vuid": "VUID-VkDeviceCreateInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceDeviceMemoryReportCreateInfoEXT, VkDeviceDiagnosticsConfigCreateInfoNV, VkDeviceGroupDeviceCreateInfo, VkDeviceMemoryOverallocationCreateInfoAMD, VkDevicePrivateDataCreateInfoEXT, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice4444FormatsFeaturesEXT, VkPhysicalDevice8BitStorageFeatures, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceAccelerationStructureFeaturesKHR, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeatures, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceCoherentMemoryFeaturesAMD, VkPhysicalDeviceColorWriteEnableFeaturesEXT, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceCustomBorderColorFeaturesEXT, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthClipControlFeaturesEXT, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeatures, VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV, VkPhysicalDeviceDeviceMemoryReportFeaturesEXT, VkPhysicalDeviceDiagnosticsConfigFeaturesNV, VkPhysicalDeviceDynamicRenderingFeaturesKHR, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT, VkPhysicalDeviceExternalMemoryRDMAFeaturesNV, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV, VkPhysicalDeviceFragmentShadingRateFeaturesKHR, VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT, VkPhysicalDeviceHostQueryResetFeatures, VkPhysicalDeviceImageRobustnessFeaturesEXT, VkPhysicalDeviceImageViewMinLodFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeatures, VkPhysicalDeviceIndexTypeUint8FeaturesEXT, VkPhysicalDeviceInheritedViewportScissorFeaturesNV, VkPhysicalDeviceInlineUniformBlockFeaturesEXT, VkPhysicalDeviceInvocationMaskFeaturesHUAWEI, VkPhysicalDeviceLineRasterizationFeaturesEXT, VkPhysicalDeviceMaintenance4FeaturesKHR, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiDrawFeaturesEXT, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE, VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, VkPhysicalDevicePerformanceQueryFeaturesKHR, VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, VkPhysicalDevicePortabilitySubsetFeaturesKHR, VkPhysicalDevicePresentIdFeaturesKHR, VkPhysicalDevicePresentWaitFeaturesKHR, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, VkPhysicalDevicePrivateDataFeaturesEXT, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceProvokingVertexFeaturesEXT, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT, VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM, VkPhysicalDeviceRayQueryFeaturesKHR, VkPhysicalDeviceRayTracingMotionBlurFeaturesNV, VkPhysicalDeviceRayTracingPipelineFeaturesKHR, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceRobustness2FeaturesEXT, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeatures, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT, VkPhysicalDeviceShaderAtomicInt64Features, VkPhysicalDeviceShaderClockFeaturesKHR, VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderFloat16Int8Features, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT, VkPhysicalDeviceSubpassShadingFeaturesHUAWEI, VkPhysicalDeviceSynchronization2FeaturesKHR, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT, VkPhysicalDeviceTimelineSemaphoreFeatures, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeatures, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT, VkPhysicalDeviceVulkan11Features, VkPhysicalDeviceVulkan12Features, VkPhysicalDeviceVulkanMemoryModelFeatures, VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT, or VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR" + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceDeviceMemoryReportCreateInfoEXT, VkDeviceDiagnosticsConfigCreateInfoNV, VkDeviceGroupDeviceCreateInfo, VkDeviceMemoryOverallocationCreateInfoAMD, VkDevicePrivateDataCreateInfoEXT, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice4444FormatsFeaturesEXT, VkPhysicalDevice8BitStorageFeatures, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceAccelerationStructureFeaturesKHR, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeatures, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceCoherentMemoryFeaturesAMD, VkPhysicalDeviceColorWriteEnableFeaturesEXT, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceCustomBorderColorFeaturesEXT, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthClipControlFeaturesEXT, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeatures, VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV, VkPhysicalDeviceDeviceMemoryReportFeaturesEXT, VkPhysicalDeviceDiagnosticsConfigFeaturesNV, VkPhysicalDeviceDynamicRenderingFeaturesKHR, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT, VkPhysicalDeviceExternalMemoryRDMAFeaturesNV, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV, VkPhysicalDeviceFragmentShadingRateFeaturesKHR, VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT, VkPhysicalDeviceHostQueryResetFeatures, VkPhysicalDeviceImageRobustnessFeaturesEXT, VkPhysicalDeviceImageViewMinLodFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeatures, VkPhysicalDeviceIndexTypeUint8FeaturesEXT, VkPhysicalDeviceInheritedViewportScissorFeaturesNV, VkPhysicalDeviceInlineUniformBlockFeaturesEXT, VkPhysicalDeviceInvocationMaskFeaturesHUAWEI, VkPhysicalDeviceLineRasterizationFeaturesEXT, VkPhysicalDeviceLinearColorAttachmentFeaturesNV, VkPhysicalDeviceMaintenance4FeaturesKHR, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiDrawFeaturesEXT, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE, VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, VkPhysicalDevicePerformanceQueryFeaturesKHR, VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, VkPhysicalDevicePortabilitySubsetFeaturesKHR, VkPhysicalDevicePresentIdFeaturesKHR, VkPhysicalDevicePresentWaitFeaturesKHR, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, VkPhysicalDevicePrivateDataFeaturesEXT, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceProvokingVertexFeaturesEXT, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT, VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM, VkPhysicalDeviceRayQueryFeaturesKHR, VkPhysicalDeviceRayTracingMotionBlurFeaturesNV, VkPhysicalDeviceRayTracingPipelineFeaturesKHR, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceRobustness2FeaturesEXT, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeatures, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT, VkPhysicalDeviceShaderAtomicInt64Features, VkPhysicalDeviceShaderClockFeaturesKHR, VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderFloat16Int8Features, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT, VkPhysicalDeviceSubpassShadingFeaturesHUAWEI, VkPhysicalDeviceSynchronization2FeaturesKHR, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT, VkPhysicalDeviceTimelineSemaphoreFeatures, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeatures, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT, VkPhysicalDeviceVulkan11Features, VkPhysicalDeviceVulkan12Features, VkPhysicalDeviceVulkanMemoryModelFeatures, VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT, or VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR" }, { "vuid": "VUID-VkDeviceCreateInfo-sType-unique", @@ -1347,6 +1347,12 @@ "text": " If rasterizationSamples is not 0, rasterizationSamples must be a valid VkSampleCountFlagBits value" } ], + "(VK_KHR_dynamic_rendering)+(VK_NV_linear_color_attachment)": [ + { + "vuid": "VUID-VkCommandBufferInheritanceRenderingInfoKHR-pColorAttachmentFormats-06492", + "text": " When rendering to a Linear Color attachment, if any element of pColorAttachmentFormats is not VK_FORMAT_UNDEFINED, it must be a format with potential format features that include VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV" + } + ], "(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_multiview)": [ { "vuid": "VUID-VkCommandBufferInheritanceRenderingInfoKHR-viewMask-06009", @@ -7489,6 +7495,20 @@ "text": " If preserveAttachmentCount is not 0, pPreserveAttachments must be a valid pointer to an array of preserveAttachmentCount uint32_t values" } ], + "(VK_NV_linear_color_attachment)": [ + { + "vuid": "VUID-VkSubpassDescription-linearColorAttachment-06496", + "text": " If the linearColorAttachment feature is enabled and the image is created with VK_IMAGE_TILING_LINEAR, all attachments in pInputAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features must contain VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV" + }, + { + "vuid": "VUID-VkSubpassDescription-linearColorAttachment-06497", + "text": " If the linearColorAttachment feature is enabled and the image is created with VK_IMAGE_TILING_LINEAR, all attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features must contain VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV" + }, + { + "vuid": "VUID-VkSubpassDescription-linearColorAttachment-06498", + "text": " If the linearColorAttachment feature is enabled and the image is created with VK_IMAGE_TILING_LINEAR, all attachments in pResolveAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features must contain VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV" + } + ], "(VK_AMD_mixed_attachment_samples)": [ { "vuid": "VUID-VkSubpassDescription-pColorAttachments-01506", @@ -8133,6 +8153,20 @@ "text": " If preserveAttachmentCount is not 0, pPreserveAttachments must be a valid pointer to an array of preserveAttachmentCount uint32_t values" } ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_NV_linear_color_attachment)": [ + { + "vuid": "VUID-VkSubpassDescription2-linearColorAttachment-06499", + "text": " If the linearColorAttachment feature is enabled and the image is created with VK_IMAGE_TILING_LINEAR, all attachments in pInputAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features must contain VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV" + }, + { + "vuid": "VUID-VkSubpassDescription2-linearColorAttachment-06500", + "text": " If the linearColorAttachment feature is enabled and the image is created with VK_IMAGE_TILING_LINEAR, all attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features must contain VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV" + }, + { + "vuid": "VUID-VkSubpassDescription2-linearColorAttachment-06501", + "text": " If the linearColorAttachment feature is enabled and the image is created with VK_IMAGE_TILING_LINEAR, all attachments in pResolveAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features must contain VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV" + } + ], "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_AMD_mixed_attachment_samples)": [ { "vuid": "VUID-VkSubpassDescription2-pColorAttachments-03070", @@ -8671,6 +8705,12 @@ "text": " If renderpass is not VK_NULL_HANDLE and flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, an element of pAttachments that is referenced by fragmentDensityMapAttachment must have a height at least as large as \\(\\left\\lceil{\\frac{height}{maxFragmentDensityTexelSize_{height}}}\\right\\rceil\\)" } ], + "(VK_EXT_fragment_density_map)+(VK_QCOM_fragment_density_map_offset)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-renderPass-06502", + "text": " If renderPass was created with fragment density map offsets other than (0,0), each element of pAttachments must have been created with a flags value including VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM." + } + ], "(VK_VERSION_1_1,VK_KHR_multiview)": [ { "vuid": "VUID-VkFramebufferCreateInfo-renderPass-04536", @@ -9538,7 +9578,67 @@ }, { "vuid": "VUID-VkSubpassEndInfo-pNext-pNext", - "text": " pNext must be NULL" + "text": " pNext must be NULL or a pointer to a valid instance of VkSubpassFragmentDensityMapOffsetEndInfoQCOM" + }, + { + "vuid": "VUID-VkSubpassEndInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + } + ] + }, + "VkSubpassFragmentDensityMapOffsetEndInfoQCOM": { + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_QCOM_fragment_density_map_offset)": [ + { + "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-fragmentDensityMapOffsets-06503", + "text": " If the fragmentDensityMapOffsets feature is not enabled or fragment density map is not enabled in the render pass, fragmentDensityOffsetCount must equal 0." + }, + { + "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-fragmentDensityMapAttachment-06504", + "text": " If VkSubpassDescription::fragmentDensityMapAttachment is not is not VK_ATTACHMENT_UNUSED and was not created with VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM, fragmentDensityOffsetCount must equal 0." + }, + { + "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-pDepthStencilAttachment-06505", + "text": " If VkSubpassDescription::pDepthStencilAttachment is not is not VK_ATTACHMENT_UNUSED and was not created with VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM, fragmentDensityOffsetCount must equal 0." + }, + { + "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-pInputAttachments-06506", + "text": " If any element of VkSubpassDescription::pInputAttachments is not is not VK_ATTACHMENT_UNUSED and was not created with VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM, fragmentDensityOffsetCount must equal 0." + }, + { + "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-pColorAttachments-06507", + "text": " If any element of VkSubpassDescription::pColorAttachments is not is not VK_ATTACHMENT_UNUSED and was not created with VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM, fragmentDensityOffsetCount must equal 0." + }, + { + "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-pResolveAttachments-06508", + "text": " If any element of VkSubpassDescription::pResolveAttachments is not is not VK_ATTACHMENT_UNUSED and was not created with VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM, fragmentDensityOffsetCount must equal 0." + }, + { + "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-pPreserveAttachments-06509", + "text": " If any element of VkSubpassDescription::pPreserveAttachments is not is not VK_ATTACHMENT_UNUSED and was not created with VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM, fragmentDensityOffsetCount must equal 0." + }, + { + "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-fragmentDensityOffsetCount-06510", + "text": " If fragmentDensityOffsetCount is not 0 and multiview is enabled for the render pass, fragmentDensityOffsetCount must equal the layerCount that was specified in creating the fragment density map attachment view." + }, + { + "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-fragmentDensityOffsetCount-06511", + "text": " If fragmentDensityOffsetCount is not 0 and multiview is not enabled for the render pass, fragmentDensityOffsetCount must equal 1." + }, + { + "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-x-06512", + "text": " The x component of each element of pFragmentDensityOffsets must be an integer multiple of fragmentDensityOffsetGranularity.width." + }, + { + "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-y-06513", + "text": " The y component of each element of pFragmentDensityOffsets must be an integer multiple of fragmentDensityOffsetGranularity.height." + }, + { + "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM" + }, + { + "vuid": "VUID-VkSubpassFragmentDensityMapOffsetEndInfoQCOM-pFragmentDensityOffsets-parameter", + "text": " If fragmentDensityOffsetCount is not 0, pFragmentDensityOffsets must be a valid pointer to an array of fragmentDensityOffsetCount VkOffset2D structures" } ] }, @@ -10433,10 +10533,6 @@ "text": " If renderPass is not VK_NULL_HANDLE, the pipeline is being created with fragment output interface state, and subpass uses color attachments, pColorBlendState must be a valid pointer to a valid VkPipelineColorBlendStateCreateInfo structure" }, { - "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06045", - "text": " If renderPass is not VK_NULL_HANDLE and the pipeline is being created with fragment output interface state, pColorBlendState->attachmentCount must be greater than the index of all color attachments that are not VK_ATTACHMENT_UNUSED for the subpass index in renderPass" - }, - { "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00754", "text": " If the pipeline is being created with pre-rasterization shader state, the depth bias clamping feature is not enabled, no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BIAS, and the depthBiasEnable member of pRasterizationState is VK_TRUE, the depthBiasClamp member of pRasterizationState must be 0.0" }, @@ -11017,11 +11113,19 @@ ] }, "VkPipelineRenderingCreateInfoKHR": { - "(VK_KHR_dynamic_rendering)": [ + "(VK_KHR_dynamic_rendering)+!(VK_NV_linear_color_attachment)": [ { "vuid": "VUID-VkPipelineRenderingCreateInfoKHR-pColorAttachmentFormats-06064", "text": " If any element of pColorAttachmentFormats is not VK_FORMAT_UNDEFINED, it must be a format with potential format features that include VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" - }, + } + ], + "(VK_KHR_dynamic_rendering)+(VK_NV_linear_color_attachment)": [ + { + "vuid": "VUID-VkPipelineRenderingCreateInfoKHR-pColorAttachmentFormats-06495", + "text": " If any element of pColorAttachmentFormats is not VK_FORMAT_UNDEFINED, it must be a format with potential format features that includes either VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT or VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV" + } + ], + "(VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-VkPipelineRenderingCreateInfoKHR-depthAttachmentFormat-06065", "text": " If depthAttachmentFormat is not VK_FORMAT_UNDEFINED, it must be a format with potential format features that include VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" @@ -14699,14 +14803,6 @@ "text": " If samples is not VK_SAMPLE_COUNT_1_BIT, usage must not contain VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT" }, { - "vuid": "VUID-VkImageCreateInfo-usage-02559", - "text": " If usage includes VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, extent.width must be less than or equal to \\(\\left\\lceil{\\frac{maxFramebufferWidth}{minFragmentDensityTexelSize_{width}}}\\right\\rceil\\)" - }, - { - "vuid": "VUID-VkImageCreateInfo-usage-02560", - "text": " If usage includes VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, extent.height must be less than or equal to \\(\\left\\lceil{\\frac{maxFramebufferHeight}{minFragmentDensityTexelSize_{height}}}\\right\\rceil\\)" - }, - { "vuid": "VUID-VkImageCreateInfo-flags-02565", "text": " If flags contains VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT, tiling must be VK_IMAGE_TILING_OPTIMAL" }, @@ -14729,6 +14825,26 @@ "text": " If flags contains VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, imageType must be VK_IMAGE_TYPE_3D" } ], + "(VK_EXT_fragment_density_map)+!(VK_QCOM_fragment_density_map_offset)": [ + { + "vuid": "VUID-VkImageCreateInfo-usage-02559", + "text": " If usage includes VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, extent.width must be less than or equal to \\(\\left\\lceil{\\frac{maxFramebufferWidth}{minFragmentDensityTexelSize_{width}}}\\right\\rceil\\)" + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-02560", + "text": " If usage includes VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, extent.height must be less than or equal to \\(\\left\\lceil{\\frac{maxFramebufferHeight}{minFragmentDensityTexelSize_{height}}}\\right\\rceil\\)" + } + ], + "(VK_EXT_fragment_density_map)+(VK_QCOM_fragment_density_map_offset)": [ + { + "vuid": "VUID-VkImageCreateInfo-fragmentDensityMapOffset-06514", + "text": " If fragmentDensityMapOffset is not enabled and usage includes VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, extent.width must be less than or equal to \\(\\left\\lceil{\\frac{maxFramebufferWidth}{minFragmentDensityTexelSize_{width}}}\\right\\rceil\\)" + }, + { + "vuid": "VUID-VkImageCreateInfo-fragmentDensityMapOffset-06515", + "text": " If fragmentDensityMapOffset is not enabled and usage includes VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, extent.height must be less than or equal to \\(\\left\\lceil{\\frac{maxFramebufferHeight}{minFragmentDensityTexelSize_{height}}}\\right\\rceil\\)" + } + ], "(VK_VERSION_1_1)": [ { "vuid": "VUID-VkImageCreateInfo-flags-01890", @@ -14938,7 +15054,7 @@ "(VK_KHR_video_decode_queue)": [ { "vuid": "VUID-VkImageCreateInfo-usage-04815", - "text": " If usage includes VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR, VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR, VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR, then the pNext chain must include a valid VkVideoProfilesKHR structure which includes at least one VkVideoProfileKHR with a decode codec-operation" + "text": " If usage includes VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR, VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR, then the pNext chain must include a valid VkVideoProfilesKHR structure which includes at least one VkVideoProfileKHR with a decode codec-operation" } ], "(VK_KHR_video_encode_queue)": [ @@ -15457,6 +15573,16 @@ "text": " If subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, image is a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange.layerCount must be non-zero and subresourceRange.baseArrayLayer + subresourceRange.layerCount must be less than or equal to the depth computed from baseMipLevel and extent.depth specified in VkImageCreateInfo when image was created, according to the formula defined in Image Miplevel Sizing" } ], + "(VK_NV_linear_color_attachment)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-usage-06516", + "text": " If usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, then the image view’s format features must contain VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV, if the image is created with VK_IMAGE_TILING_LINEAR and the linearColorAttachment feature is enabled" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-usage-06517", + "text": " If usage contains VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, then the image view’s format features must contain VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV, if the image is created with VK_IMAGE_TILING_LINEAR and the linearColorAttachment feature is enabled" + } + ], "(VK_EXT_fragment_density_map)": [ { "vuid": "VUID-VkImageViewCreateInfo-image-02571", @@ -19335,6 +19461,10 @@ "text": " For each element i where pDescriptorWrites[i].descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER the imageView member of any element of pDescriptorWrites[i] must have been created on device" }, { + "vuid": "VUID-vkUpdateDescriptorSets-pDescriptorWrites-06493", + "text": " For each element i where pDescriptorWrites[i].descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, pDescriptorWrites[i].pImageInfo must be a valid pointer to an array of pDescriptorWrites[i].descriptorCount valid VkDescriptorImageInfo structures" + }, + { "vuid": "VUID-vkUpdateDescriptorSets-device-parameter", "text": " device must be a valid VkDevice handle" }, @@ -19403,10 +19533,6 @@ "text": " The sum of dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by dstBinding, and all applicable consecutive bindings, as described by consecutive binding updates" }, { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00322", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, pImageInfo must be a valid pointer to an array of descriptorCount valid VkDescriptorImageInfo structures" - }, - { "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02994", "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, each element of pTexelBufferView must be either a valid VkBufferView handle or VK_NULL_HANDLE" }, @@ -20073,6 +20199,10 @@ "text": " set must be the unique set number in the pipeline layout that uses a descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR" }, { + "vuid": "VUID-vkCmdPushDescriptorSetKHR-pDescriptorWrites-06494", + "text": " For each element i where pDescriptorWrites[i].descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, pDescriptorWrites[i].pImageInfo must be a valid pointer to an array of pDescriptorWrites[i].descriptorCount valid VkDescriptorImageInfo structures" + }, + { "vuid": "VUID-vkCmdPushDescriptorSetKHR-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" }, @@ -21986,7 +22116,7 @@ }, { "vuid": "VUID-vkCmdResetQueryPool-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, compute, decode, or encode operations" }, { "vuid": "VUID-vkCmdResetQueryPool-renderpass", @@ -22092,7 +22222,7 @@ }, { "vuid": "VUID-vkCmdBeginQuery-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, compute, decode, or encode operations" }, { "vuid": "VUID-vkCmdBeginQuery-commonparent", @@ -22314,7 +22444,7 @@ }, { "vuid": "VUID-vkCmdEndQuery-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, compute, decode, or encode operations" }, { "vuid": "VUID-vkCmdEndQuery-commonparent", @@ -22576,12 +22706,6 @@ "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-02734", "text": " vkCmdCopyQueryPoolResults must not be called if the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL" } - ], - "(VK_KHR_video_queue)": [ - { - "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-04812", - "text": " vkCmdCopyQueryPoolResults must not be called if the queryType used to create queryPool was VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR or VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR" - } ] }, "vkCmdWriteTimestamp2KHR": { @@ -22640,7 +22764,7 @@ }, { "vuid": "VUID-vkCmdWriteTimestamp2KHR-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, compute, decode, or encode operations" }, { "vuid": "VUID-vkCmdWriteTimestamp2KHR-commonparent", @@ -22752,7 +22876,7 @@ }, { "vuid": "VUID-vkCmdWriteTimestamp-commandBuffer-cmdpool", - "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, compute, decode, or encode operations" }, { "vuid": "VUID-vkCmdWriteTimestamp-commonparent", @@ -23100,6 +23224,14 @@ } ] }, + "VkQueueFamilyQueryResultStatusProperties2KHR": { + "(VK_KHR_video_queue)": [ + { + "vuid": "VUID-VkQueueFamilyQueryResultStatusProperties2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR" + } + ] + }, "vkCmdClearColorImage": { "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ { @@ -26413,6 +26545,12 @@ "text": " dstImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" } ], + "(VK_NV_linear_color_attachment)": [ + { + "vuid": "VUID-vkCmdResolveImage-linearColorAttachment-06519", + "text": " If the linearColorAttachment feature is enabled and the image is created with VK_IMAGE_TILING_LINEAR, the format features of dstImage must contain VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV" + } + ], "(VK_EXT_fragment_density_map)": [ { "vuid": "VUID-vkCmdResolveImage-dstImage-02546", @@ -26845,6 +26983,12 @@ "text": " dstImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" } ], + "(VK_KHR_copy_commands2)+(VK_NV_linear_color_attachment)": [ + { + "vuid": "VUID-VkResolveImageInfo2KHR-linearColorAttachment-06519", + "text": " If the linearColorAttachment feature is enabled and the image is created with VK_IMAGE_TILING_LINEAR, the format features of dstImage must contain VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV" + } + ], "(VK_KHR_copy_commands2)+(VK_EXT_fragment_density_map)": [ { "vuid": "VUID-VkResolveImageInfo2KHR-dstImage-02546", @@ -38729,6 +38873,10 @@ "vkGetPhysicalDeviceSurfaceCapabilitiesKHR": { "(VK_KHR_surface)": [ { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-surface-06523", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-surface-06211", "text": " surface must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" }, @@ -38753,6 +38901,10 @@ "vkGetPhysicalDeviceSurfaceCapabilities2KHR": { "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_EXT_full_screen_exclusive+VK_KHR_win32_surface)": [ { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceInfo-06520", + "text": " pSurfaceInfo->surface must be a valid VkSurfaceKHR handle" + }, + { "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceInfo-06210", "text": " pSurfaceInfo->surface must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" }, @@ -38783,6 +38935,26 @@ "text": " If the pNext chain includes a VkSurfaceFullScreenExclusiveInfoEXT structure with its fullScreenExclusive member set to VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT, and surface was created using vkCreateWin32SurfaceKHR, a VkSurfaceFullScreenExclusiveWin32InfoEXT structure must be included in the pNext chain" } ], + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_KHR_win32_surface+VK_EXT_full_screen_exclusive)+(VK_GOOGLE_surfaceless_query)": [ + { + "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-pSurfaceInfo-06526", + "text": " When passed as the pSurfaceInfo parameter of vkGetPhysicalDeviceSurfaceCapabilities2KHR, if the VK_GOOGLE_surfaceless_query extension is enabled and the pNext chain of the pSurfaceCapabilities parameter includes VkSurfaceProtectedCapabilitiesKHR, then surface can be VK_NULL_HANDLE. Otherwise, surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-pSurfaceInfo-06527", + "text": " When passed as the pSurfaceInfo parameter of vkGetPhysicalDeviceSurfaceFormats2KHR, if the VK_GOOGLE_surfaceless_query extension is enabled, then surface can be VK_NULL_HANDLE. Otherwise, surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-pSurfaceInfo-06528", + "text": " When passed as the pSurfaceInfo parameter of vkGetPhysicalDeviceSurfacePresentModes2EXT, if the VK_GOOGLE_surfaceless_query extension is enabled, then surface can be VK_NULL_HANDLE. Otherwise, surface must be a valid VkSurfaceKHR handle" + } + ], + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_KHR_win32_surface+VK_EXT_full_screen_exclusive)+!(VK_GOOGLE_surfaceless_query)": [ + { + "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-06529", + "text": " surface must be a valid VkSurfaceKHR handle" + } + ], "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [ { "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-sType-sType", @@ -38798,7 +38970,7 @@ }, { "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter", - "text": " surface must be a valid VkSurfaceKHR handle" + "text": " If surface is not VK_NULL_HANDLE, surface must be a valid VkSurfaceKHR handle" } ] }, @@ -38877,6 +39049,10 @@ "vkGetPhysicalDeviceSurfaceCapabilities2EXT": { "(VK_KHR_surface)+(VK_EXT_display_surface_counter)": [ { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-surface-06523", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-surface-06211", "text": " surface must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" }, @@ -38915,18 +39091,34 @@ ] }, "vkGetPhysicalDeviceSurfaceFormatsKHR": { - "(VK_KHR_surface)": [ + "(VK_KHR_surface)+(VK_GOOGLE_surfaceless_query)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-06524", + "text": " If the VK_GOOGLE_surfaceless_query extension is not enabled, surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-06525", + "text": " If surface is not VK_NULL_HANDLE, it must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" + } + ], + "(VK_KHR_surface)+!(VK_GOOGLE_surfaceless_query)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-06523", + "text": " surface must be a valid VkSurfaceKHR handle" + }, { "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-06211", "text": " surface must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" - }, + } + ], + "(VK_KHR_surface)": [ { "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter", "text": " physicalDevice must be a valid VkPhysicalDevice handle" }, { "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-parameter", - "text": " surface must be a valid VkSurfaceKHR handle" + "text": " If surface is not VK_NULL_HANDLE, surface must be a valid VkSurfaceKHR handle" }, { "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-pSurfaceFormatCount-parameter", @@ -38938,16 +39130,32 @@ }, { "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-commonparent", - "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" + "text": " Both of physicalDevice, and surface that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkInstance" } ] }, "vkGetPhysicalDeviceSurfaceFormats2KHR": { - "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [ + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_GOOGLE_surfaceless_query)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-06521", + "text": " If the VK_GOOGLE_surfaceless_query extension is not enabled, pSurfaceInfo->surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-06522", + "text": " If pSurfaceInfo->surface is not VK_NULL_HANDLE, it must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" + } + ], + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+!(VK_GOOGLE_surfaceless_query)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-06520", + "text": " pSurfaceInfo->surface must be a valid VkSurfaceKHR handle" + }, { "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-06210", "text": " pSurfaceInfo->surface must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" - }, + } + ], + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [ { "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter", "text": " physicalDevice must be a valid VkPhysicalDevice handle" @@ -38979,18 +39187,34 @@ ] }, "vkGetPhysicalDeviceSurfacePresentModesKHR": { - "(VK_KHR_surface)": [ + "(VK_KHR_surface)+(VK_GOOGLE_surfaceless_query)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-06524", + "text": " If the VK_GOOGLE_surfaceless_query extension is not enabled, surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-06525", + "text": " If surface is not VK_NULL_HANDLE, it must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" + } + ], + "(VK_KHR_surface)+!(VK_GOOGLE_surfaceless_query)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-06523", + "text": " surface must be a valid VkSurfaceKHR handle" + }, { "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-06211", "text": " surface must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" - }, + } + ], + "(VK_KHR_surface)": [ { "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-physicalDevice-parameter", "text": " physicalDevice must be a valid VkPhysicalDevice handle" }, { "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-parameter", - "text": " surface must be a valid VkSurfaceKHR handle" + "text": " If surface is not VK_NULL_HANDLE, surface must be a valid VkSurfaceKHR handle" }, { "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-pPresentModeCount-parameter", @@ -39002,16 +39226,32 @@ }, { "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-commonparent", - "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" + "text": " Both of physicalDevice, and surface that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkInstance" } ] }, "vkGetPhysicalDeviceSurfacePresentModes2EXT": { - "(VK_KHR_surface)+(VK_EXT_full_screen_exclusive)": [ + "(VK_KHR_surface)+(VK_EXT_full_screen_exclusive)+(VK_GOOGLE_surfaceless_query)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-pSurfaceInfo-06521", + "text": " If the VK_GOOGLE_surfaceless_query extension is not enabled, pSurfaceInfo->surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-pSurfaceInfo-06522", + "text": " If pSurfaceInfo->surface is not VK_NULL_HANDLE, it must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" + } + ], + "(VK_KHR_surface)+(VK_EXT_full_screen_exclusive)+!(VK_GOOGLE_surfaceless_query)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-pSurfaceInfo-06520", + "text": " pSurfaceInfo->surface must be a valid VkSurfaceKHR handle" + }, { "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-pSurfaceInfo-06210", "text": " pSurfaceInfo->surface must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" - }, + } + ], + "(VK_KHR_surface)+(VK_EXT_full_screen_exclusive)": [ { "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-physicalDevice-parameter", "text": " physicalDevice must be a valid VkPhysicalDevice handle" @@ -39141,6 +39381,10 @@ "vkGetPhysicalDevicePresentRectanglesKHR": { "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ { + "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-surface-06523", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-surface-06211", "text": " surface must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" }, @@ -43887,6 +44131,10 @@ "VkVideoCodingControlInfoKHR": { "(VK_KHR_video_queue)": [ { + "vuid": "VUID-VkVideoCodingControlInfoKHR-flags-06518", + "text": " The first command buffer submitted for a newly created video session must set the VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR bit in VkVideoCodingControlInfoKHR::flags to reset the session device context before any video decode or encode operations are performed on the session." + }, + { "vuid": "VUID-VkVideoCodingControlInfoKHR-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR" }, @@ -44321,6 +44569,26 @@ ] }, "VkVideoEncodeRateControlInfoKHR": { + "(VK_KHR_video_encode_queue)+(VK_EXT_video_encode_h264)": [ + { + "vuid": "VUID-VkVideoEncodeH264RateControlInfoEXT-chainrequirement", + "text": " VkVideoEncodeH264RateControlInfoEXT must be included in the pNext chain of VkVideoEncodeRateControlInfoKHR if and only if VkVideoEncodeRateControlInfoKHR::rateControlMode is not VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR and the bound video session was created with VkVideoProfileKHR::videoCodecOperation set to VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT." + }, + { + "vuid": "VUID-VkVideoEncodeH264RateControlInfoEXT-temporalLayerCount", + "text": " If VkVideoEncodeRateControlInfoKHR::layerCount is greater than 1, then VkVideoEncodeH264RateControlInfoEXT::temporalLayerCount must be equal to layerCount." + } + ], + "(VK_KHR_video_encode_queue)+(VK_EXT_video_encode_h265)": [ + { + "vuid": "VUID-VkVideoEncodeH265RateControlInfoEXT-chainrequirement", + "text": " VkVideoEncodeH265RateControlInfoEXT must be included in the pNext chain of VkVideoEncodeRateControlInfoKHR if and only if VkVideoEncodeRateControlInfoKHR::rateControlMode is not VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR and the bound video session was created with VkVideoProfileKHR::videoCodecOperation set to VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT." + }, + { + "vuid": "VUID-VkVideoEncodeH265RateControlInfoEXT-subLayerCount", + "text": " If VkVideoEncodeRateControlInfoKHR::layerCount is greater than 1, then VkVideoEncodeH265RateControlInfoEXT::subLayerCount must be equal to layerCount." + } + ], "(VK_KHR_video_encode_queue)": [ { "vuid": "VUID-VkVideoEncodeRateControlInfoKHR-sType-sType", @@ -45265,13 +45533,21 @@ ] }, "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT": { - "(VK_EXT_fragment_density_map2)": [ + "(VK_EXT_fragment_density_map)+(VK_EXT_fragment_density_map2)": [ { "vuid": "VUID-VkPhysicalDeviceFragmentDensityMap2FeaturesEXT-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT" } ] }, + "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM": { + "(VK_EXT_fragment_density_map)+(VK_QCOM_fragment_density_map_offset)": [ + { + "vuid": "VUID-VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM" + } + ] + }, "VkPhysicalDeviceInvocationMaskFeaturesHUAWEI": { "(VK_HUAWEI_invocation_mask)": [ { @@ -45864,6 +46140,14 @@ } ] }, + "VkPhysicalDeviceLinearColorAttachmentFeaturesNV": { + "(VK_NV_linear_color_attachment)": [ + { + "vuid": "VUID-VkPhysicalDeviceLinearColorAttachmentFeaturesNV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV" + } + ] + }, "VkPhysicalDevicePushDescriptorPropertiesKHR": { "(VK_KHR_push_descriptor)": [ { @@ -46033,13 +46317,21 @@ ] }, "VkPhysicalDeviceFragmentDensityMap2PropertiesEXT": { - "(VK_EXT_fragment_density_map2)": [ + "(VK_EXT_fragment_density_map)+(VK_EXT_fragment_density_map2)": [ { "vuid": "VUID-VkPhysicalDeviceFragmentDensityMap2PropertiesEXT-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT" } ] }, + "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM": { + "(VK_EXT_fragment_density_map)+(VK_QCOM_fragment_density_map_offset)": [ + { + "vuid": "VUID-VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM" + } + ] + }, "VkPhysicalDeviceShaderCorePropertiesAMD": { "(VK_AMD_shader_core_properties)": [ { @@ -47997,6 +48289,10 @@ "text": " The product of x size, y size, and z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupInvocations" }, { + "vuid": "VUID-RuntimeSpirv-Workgroup-06530", + "text": " The sum of size in bytes for variables and padding in the Workgroup storage class in the GLCompute {ExecutionModel} must be less than or equal to maxComputeSharedMemorySize" + }, + { "vuid": "VUID-RuntimeSpirv-OpImage-06376", "text": " If an OpImage*Gather operation has an image operand of Offset, ConstOffset, or ConstOffsets the offset value must be greater than or equal to minTexelGatherOffset" }, @@ -48592,19 +48888,11 @@ }, { "vuid": "VUID-VkCuLaunchInfoNVX-pParams-parameter", - "text": " pParams must be a valid pointer to an array of paramCount bytes" + "text": " If paramCount is not 0, pParams must be a valid pointer to an array of paramCount bytes" }, { "vuid": "VUID-VkCuLaunchInfoNVX-pExtras-parameter", - "text": " pExtras must be a valid pointer to an array of extraCount bytes" - }, - { - "vuid": "VUID-VkCuLaunchInfoNVX-paramCount-arraylength", - "text": " paramCount must be greater than 0" - }, - { - "vuid": "VUID-VkCuLaunchInfoNVX-extraCount-arraylength", - "text": " extraCount must be greater than 0" + "text": " If extraCount is not 0, pExtras must be a valid pointer to an array of extraCount bytes" } ] } diff --git a/registry/vk.xml b/registry/vk.xml index 56b4890..6a8d05e 100644 --- a/registry/vk.xml +++ b/registry/vk.xml @@ -155,7 +155,7 @@ branch of the member gitlab server. // Vulkan 1.2 version number #define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 202 +#define VK_HEADER_VERSION 203 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 2, VK_HEADER_VERSION) @@ -2922,7 +2922,7 @@ typedef void CAMetalLayer; VkStructureType sType const void* pNext - VkSurfaceKHR surface + VkSurfaceKHR surface VkStructureType sType @@ -4304,26 +4304,42 @@ typedef void CAMetalLayer; void* pNext VkBool32 fragmentDensityMapDeferred + + VkStructureType sType + void* pNext + VkBool32 fragmentDensityMapOffset + VkStructureType sType void* pNext VkExtent2D minFragmentDensityTexelSize VkExtent2D maxFragmentDensityTexelSize - VkBool32 fragmentDensityInvocations + VkBool32 fragmentDensityInvocations VkStructureType sType void* pNext - VkBool32 subsampledLoads - VkBool32 subsampledCoarseReconstructionEarlyAccess + VkBool32 subsampledLoads + VkBool32 subsampledCoarseReconstructionEarlyAccess uint32_t maxSubsampledArrayLayers uint32_t maxDescriptorSetSubsampledSamplers + + VkStructureType sType + void* pNext + VkExtent2D fragmentDensityOffsetGranularity + VkStructureType sType const void* pNext VkAttachmentReference fragmentDensityMapAttachment + + VkStructureType sType + const void* pNext + uint32_t fragmentDensityOffsetCount + const VkOffset2D* pFragmentDensityOffsets + VkStructureType sType void* pNext @@ -5616,6 +5632,11 @@ typedef void CAMetalLayer; void* pNext VkVideoCodecOperationFlagsKHR videoCodecOperations + + VkStructureTypesType + void* pNext + VkBool32 supported + VkStructureTypesType void* pNext @@ -6013,6 +6034,7 @@ typedef void CAMetalLayer; uint32_t idrPeriod uint32_t consecutiveBFrameCount VkVideoEncodeH264RateControlStructureFlagBitsEXT rateControlStructure + uint8_t temporalLayerCount int32_t qpI @@ -6117,6 +6139,7 @@ typedef void CAMetalLayer; uint32_t idrPeriod uint32_t consecutiveBFrameCount VkVideoEncodeH265RateControlStructureFlagBitsEXT rateControlStructure + uint8_t subLayerCount int32_t qpI @@ -6218,9 +6241,9 @@ typedef void CAMetalLayer; uint32_t blockDimY uint32_t blockDimZ uint32_t sharedMemBytes - size_t paramCount + size_t paramCount const void* const * pParams - size_t extraCount + size_t extraCount const void* const * pExtras @@ -6550,6 +6573,11 @@ typedef void CAMetalLayer; VkBool32 rasterizationOrderDepthAttachmentAccess VkBool32 rasterizationOrderStencilAttachmentAccess + + VkStructureType sType + void* pNext + VkBool32 linearColorAttachment + Vulkan enumerant (token) definitions @@ -8120,7 +8148,6 @@ typedef void CAMetalLayer; - @@ -9135,14 +9162,14 @@ typedef void CAMetalLayer; uint32_t imageMemoryBarrierCount const VkImageMemoryBarrier* pImageMemoryBarriers - + void vkCmdBeginQuery VkCommandBuffer commandBuffer VkQueryPool queryPool uint32_t query VkQueryControlFlags flags - + void vkCmdEndQuery VkCommandBuffer commandBuffer VkQueryPool queryPool @@ -9157,14 +9184,14 @@ typedef void CAMetalLayer; void vkCmdEndConditionalRenderingEXT VkCommandBuffer commandBuffer - + void vkCmdResetQueryPool VkCommandBuffer commandBuffer VkQueryPool queryPool uint32_t firstQuery uint32_t queryCount - + void vkCmdWriteTimestamp VkCommandBuffer commandBuffer VkPipelineStageFlagBits pipelineStage @@ -9297,14 +9324,14 @@ typedef void CAMetalLayer; VkResult vkGetPhysicalDeviceSurfaceFormatsKHR VkPhysicalDevice physicalDevice - VkSurfaceKHR surface + VkSurfaceKHR surface uint32_t* pSurfaceFormatCount VkSurfaceFormatKHR* pSurfaceFormats VkResult vkGetPhysicalDeviceSurfacePresentModesKHR VkPhysicalDevice physicalDevice - VkSurfaceKHR surface + VkSurfaceKHR surface uint32_t* pPresentModeCount VkPresentModeKHR* pPresentModes @@ -11122,7 +11149,7 @@ typedef void CAMetalLayer; const VkSubmitInfo2KHR* pSubmits VkFence fence - + void vkCmdWriteTimestamp2KHR VkCommandBuffer commandBuffer VkPipelineStageFlags2KHR stage @@ -12683,6 +12710,7 @@ typedef void CAMetalLayer; + @@ -12710,6 +12738,7 @@ typedef void CAMetalLayer; + @@ -12913,7 +12942,7 @@ typedef void CAMetalLayer; - + @@ -12955,7 +12984,7 @@ typedef void CAMetalLayer; - + @@ -17556,11 +17585,17 @@ typedef void CAMetalLayer; - + - - - + + + + + + + + + @@ -17587,10 +17622,15 @@ typedef void CAMetalLayer; - + - - + + + + + + + @@ -17605,10 +17645,10 @@ typedef void CAMetalLayer; - + - - + + @@ -17641,6 +17681,88 @@ typedef void CAMetalLayer; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -18417,13 +18539,13 @@ typedef void CAMetalLayer; - + - + -- 2.7.4