HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
vulkan_handles.hpp
Go to the documentation of this file.
1 // Copyright 2015-2022 The Khronos Group Inc.
2 //
3 // SPDX-License-Identifier: Apache-2.0 OR MIT
4 //
5 
6 // This header is generated from the Khronos Vulkan XML API Registry.
7 
8 #ifndef VULKAN_HANDLES_HPP
9 #define VULKAN_HANDLES_HPP
10 
11 namespace VULKAN_HPP_NAMESPACE
12 {
13  //===================================
14  //=== STRUCT forward declarations ===
15  //===================================
16 
17  //=== VK_VERSION_1_0 ===
18  struct Extent2D;
19  struct Extent3D;
20  struct Offset2D;
21  struct Offset3D;
22  struct Rect2D;
23  struct BaseInStructure;
24  struct BaseOutStructure;
25  struct BufferMemoryBarrier;
26  struct DispatchIndirectCommand;
27  struct DrawIndexedIndirectCommand;
28  struct DrawIndirectCommand;
29  struct ImageMemoryBarrier;
30  struct MemoryBarrier;
31  struct PipelineCacheHeaderVersionOne;
32  struct AllocationCallbacks;
33  struct ApplicationInfo;
34  struct FormatProperties;
35  struct ImageFormatProperties;
36  struct InstanceCreateInfo;
37  struct MemoryHeap;
38  struct MemoryType;
39  struct PhysicalDeviceFeatures;
40  struct PhysicalDeviceLimits;
41  struct PhysicalDeviceMemoryProperties;
42  struct PhysicalDeviceProperties;
43  struct PhysicalDeviceSparseProperties;
44  struct QueueFamilyProperties;
45  struct DeviceCreateInfo;
46  struct DeviceQueueCreateInfo;
47  struct ExtensionProperties;
48  struct LayerProperties;
49  struct SubmitInfo;
50  struct MappedMemoryRange;
51  struct MemoryAllocateInfo;
52  struct MemoryRequirements;
53  struct BindSparseInfo;
54  struct ImageSubresource;
55  struct SparseBufferMemoryBindInfo;
56  struct SparseImageFormatProperties;
57  struct SparseImageMemoryBind;
58  struct SparseImageMemoryBindInfo;
59  struct SparseImageMemoryRequirements;
60  struct SparseImageOpaqueMemoryBindInfo;
61  struct SparseMemoryBind;
62  struct FenceCreateInfo;
63  struct SemaphoreCreateInfo;
64  struct EventCreateInfo;
65  struct QueryPoolCreateInfo;
66  struct BufferCreateInfo;
67  struct BufferViewCreateInfo;
68  struct ImageCreateInfo;
69  struct SubresourceLayout;
70  struct ComponentMapping;
71  struct ImageSubresourceRange;
72  struct ImageViewCreateInfo;
73  struct ShaderModuleCreateInfo;
74  struct PipelineCacheCreateInfo;
75  struct ComputePipelineCreateInfo;
76  struct GraphicsPipelineCreateInfo;
77  struct PipelineColorBlendAttachmentState;
78  struct PipelineColorBlendStateCreateInfo;
79  struct PipelineDepthStencilStateCreateInfo;
80  struct PipelineDynamicStateCreateInfo;
81  struct PipelineInputAssemblyStateCreateInfo;
82  struct PipelineMultisampleStateCreateInfo;
83  struct PipelineRasterizationStateCreateInfo;
84  struct PipelineShaderStageCreateInfo;
85  struct PipelineTessellationStateCreateInfo;
86  struct PipelineVertexInputStateCreateInfo;
87  struct PipelineViewportStateCreateInfo;
88  struct SpecializationInfo;
89  struct SpecializationMapEntry;
90  struct StencilOpState;
91  struct VertexInputAttributeDescription;
92  struct VertexInputBindingDescription;
93  struct Viewport;
94  struct PipelineLayoutCreateInfo;
95  struct PushConstantRange;
96  struct SamplerCreateInfo;
97  struct CopyDescriptorSet;
98  struct DescriptorBufferInfo;
99  struct DescriptorImageInfo;
100  struct DescriptorPoolCreateInfo;
101  struct DescriptorPoolSize;
102  struct DescriptorSetAllocateInfo;
103  struct DescriptorSetLayoutBinding;
104  struct DescriptorSetLayoutCreateInfo;
105  struct WriteDescriptorSet;
106  struct AttachmentDescription;
107  struct AttachmentReference;
108  struct FramebufferCreateInfo;
109  struct RenderPassCreateInfo;
110  struct SubpassDependency;
111  struct SubpassDescription;
112  struct CommandPoolCreateInfo;
113  struct CommandBufferAllocateInfo;
114  struct CommandBufferBeginInfo;
115  struct CommandBufferInheritanceInfo;
116  struct BufferCopy;
117  struct BufferImageCopy;
118  struct ClearAttachment;
119  union ClearColorValue;
120  struct ClearDepthStencilValue;
121  struct ClearRect;
122  union ClearValue;
123  struct ImageBlit;
124  struct ImageCopy;
125  struct ImageResolve;
126  struct ImageSubresourceLayers;
127  struct RenderPassBeginInfo;
128 
129  //=== VK_VERSION_1_1 ===
130  struct PhysicalDeviceSubgroupProperties;
131  struct BindBufferMemoryInfo;
133  struct BindImageMemoryInfo;
147  struct DeviceGroupSubmitInfo;
165  struct MemoryRequirements2;
173  struct FormatProperties2;
175  struct ImageFormatProperties2;
179  struct QueueFamilyProperties2;
209  struct DeviceQueueInfo2;
210  struct ProtectedSubmitInfo;
249  struct ExportFenceCreateInfo;
263 
264  //=== VK_VERSION_1_2 ===
271  struct RenderPassCreateInfo2;
273  struct AttachmentDescription2;
275  struct AttachmentReference2;
277  struct SubpassDescription2;
279  struct SubpassDependency2;
281  struct SubpassBeginInfo;
283  struct SubpassEndInfo;
287  struct ConformanceVersion;
350  struct SemaphoreWaitInfo;
352  struct SemaphoreSignalInfo;
365 
366  //=== VK_VERSION_1_3 ===
387  struct MemoryBarrier2;
389  struct BufferMemoryBarrier2;
391  struct ImageMemoryBarrier2;
393  struct DependencyInfo;
395  struct SubmitInfo2;
397  struct SemaphoreSubmitInfo;
407  struct CopyBufferInfo2;
409  struct CopyImageInfo2;
411  struct CopyBufferToImageInfo2;
413  struct CopyImageToBufferInfo2;
415  struct BlitImageInfo2;
417  struct ResolveImageInfo2;
419  struct BufferCopy2;
421  struct ImageCopy2;
423  struct ImageBlit2;
425  struct BufferImageCopy2;
427  struct ImageResolve2;
445  struct RenderingInfo;
461  struct FormatProperties3;
471 
472  //=== VK_KHR_surface ===
473  struct SurfaceCapabilitiesKHR;
474  struct SurfaceFormatKHR;
475 
476  //=== VK_KHR_swapchain ===
477  struct SwapchainCreateInfoKHR;
478  struct PresentInfoKHR;
485 
486  //=== VK_KHR_display ===
492  struct DisplayPropertiesKHR;
494 
495  //=== VK_KHR_display_swapchain ===
496  struct DisplayPresentInfoKHR;
497 
498 #if defined( VK_USE_PLATFORM_XLIB_KHR )
499  //=== VK_KHR_xlib_surface ===
500  struct XlibSurfaceCreateInfoKHR;
501 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
502 
503 #if defined( VK_USE_PLATFORM_XCB_KHR )
504  //=== VK_KHR_xcb_surface ===
505  struct XcbSurfaceCreateInfoKHR;
506 #endif /*VK_USE_PLATFORM_XCB_KHR*/
507 
508 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
509  //=== VK_KHR_wayland_surface ===
510  struct WaylandSurfaceCreateInfoKHR;
511 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
512 
513 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
514  //=== VK_KHR_android_surface ===
515  struct AndroidSurfaceCreateInfoKHR;
516 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
517 
518 #if defined( VK_USE_PLATFORM_WIN32_KHR )
519  //=== VK_KHR_win32_surface ===
520  struct Win32SurfaceCreateInfoKHR;
521 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
522 
523  //=== VK_EXT_debug_report ===
525 
526  //=== VK_AMD_rasterization_order ===
528 
529  //=== VK_EXT_debug_marker ===
533 
534 #if defined( VK_ENABLE_BETA_EXTENSIONS )
535  //=== VK_KHR_video_queue ===
536  struct QueueFamilyQueryResultStatusPropertiesKHR;
537  struct QueueFamilyVideoPropertiesKHR;
538  struct VideoProfileInfoKHR;
539  struct VideoProfileListInfoKHR;
540  struct VideoCapabilitiesKHR;
541  struct PhysicalDeviceVideoFormatInfoKHR;
542  struct VideoFormatPropertiesKHR;
543  struct VideoPictureResourceInfoKHR;
544  struct VideoReferenceSlotInfoKHR;
545  struct VideoSessionMemoryRequirementsKHR;
546  struct BindVideoSessionMemoryInfoKHR;
547  struct VideoSessionCreateInfoKHR;
548  struct VideoSessionParametersCreateInfoKHR;
549  struct VideoSessionParametersUpdateInfoKHR;
550  struct VideoBeginCodingInfoKHR;
551  struct VideoEndCodingInfoKHR;
552  struct VideoCodingControlInfoKHR;
553 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
554 
555 #if defined( VK_ENABLE_BETA_EXTENSIONS )
556  //=== VK_KHR_video_decode_queue ===
557  struct VideoDecodeCapabilitiesKHR;
558  struct VideoDecodeUsageInfoKHR;
559  struct VideoDecodeInfoKHR;
560 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
561 
562  //=== VK_NV_dedicated_allocation ===
566 
567  //=== VK_EXT_transform_feedback ===
571 
572  //=== VK_NVX_binary_import ===
573  struct CuModuleCreateInfoNVX;
575  struct CuLaunchInfoNVX;
576 
577  //=== VK_NVX_image_view_handle ===
578  struct ImageViewHandleInfoNVX;
580 
581 #if defined( VK_ENABLE_BETA_EXTENSIONS )
582  //=== VK_EXT_video_encode_h264 ===
583  struct VideoEncodeH264CapabilitiesEXT;
584  struct VideoEncodeH264SessionParametersCreateInfoEXT;
585  struct VideoEncodeH264SessionParametersAddInfoEXT;
586  struct VideoEncodeH264VclFrameInfoEXT;
587  struct VideoEncodeH264ReferenceListsInfoEXT;
588  struct VideoEncodeH264EmitPictureParametersInfoEXT;
589  struct VideoEncodeH264DpbSlotInfoEXT;
590  struct VideoEncodeH264NaluSliceInfoEXT;
591  struct VideoEncodeH264ProfileInfoEXT;
592  struct VideoEncodeH264RateControlInfoEXT;
593  struct VideoEncodeH264RateControlLayerInfoEXT;
594  struct VideoEncodeH264QpEXT;
595  struct VideoEncodeH264FrameSizeEXT;
596 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
597 
598 #if defined( VK_ENABLE_BETA_EXTENSIONS )
599  //=== VK_EXT_video_encode_h265 ===
600  struct VideoEncodeH265CapabilitiesEXT;
601  struct VideoEncodeH265SessionParametersCreateInfoEXT;
602  struct VideoEncodeH265SessionParametersAddInfoEXT;
603  struct VideoEncodeH265VclFrameInfoEXT;
604  struct VideoEncodeH265EmitPictureParametersInfoEXT;
605  struct VideoEncodeH265DpbSlotInfoEXT;
606  struct VideoEncodeH265NaluSliceSegmentInfoEXT;
607  struct VideoEncodeH265ProfileInfoEXT;
608  struct VideoEncodeH265ReferenceListsInfoEXT;
609  struct VideoEncodeH265RateControlInfoEXT;
610  struct VideoEncodeH265RateControlLayerInfoEXT;
611  struct VideoEncodeH265QpEXT;
612  struct VideoEncodeH265FrameSizeEXT;
613 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
614 
615 #if defined( VK_ENABLE_BETA_EXTENSIONS )
616  //=== VK_EXT_video_decode_h264 ===
617  struct VideoDecodeH264ProfileInfoEXT;
618  struct VideoDecodeH264CapabilitiesEXT;
619  struct VideoDecodeH264SessionParametersCreateInfoEXT;
620  struct VideoDecodeH264SessionParametersAddInfoEXT;
621  struct VideoDecodeH264PictureInfoEXT;
622  struct VideoDecodeH264DpbSlotInfoEXT;
623 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
624 
625  //=== VK_AMD_texture_gather_bias_lod ===
627 
628  //=== VK_AMD_shader_info ===
629  struct ShaderResourceUsageAMD;
631 
632  //=== VK_KHR_dynamic_rendering ===
638 
639 #if defined( VK_USE_PLATFORM_GGP )
640  //=== VK_GGP_stream_descriptor_surface ===
641  struct StreamDescriptorSurfaceCreateInfoGGP;
642 #endif /*VK_USE_PLATFORM_GGP*/
643 
644  //=== VK_NV_corner_sampled_image ===
646 
647  //=== VK_NV_external_memory_capabilities ===
649 
650  //=== VK_NV_external_memory ===
653 
654 #if defined( VK_USE_PLATFORM_WIN32_KHR )
655  //=== VK_NV_external_memory_win32 ===
656  struct ImportMemoryWin32HandleInfoNV;
657  struct ExportMemoryWin32HandleInfoNV;
658 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
659 
660 #if defined( VK_USE_PLATFORM_WIN32_KHR )
661  //=== VK_NV_win32_keyed_mutex ===
662  struct Win32KeyedMutexAcquireReleaseInfoNV;
663 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
664 
665  //=== VK_EXT_validation_flags ===
666  struct ValidationFlagsEXT;
667 
668 #if defined( VK_USE_PLATFORM_VI_NN )
669  //=== VK_NN_vi_surface ===
670  struct ViSurfaceCreateInfoNN;
671 #endif /*VK_USE_PLATFORM_VI_NN*/
672 
673  //=== VK_EXT_astc_decode_mode ===
676 
677  //=== VK_EXT_pipeline_robustness ===
681 
682 #if defined( VK_USE_PLATFORM_WIN32_KHR )
683  //=== VK_KHR_external_memory_win32 ===
684  struct ImportMemoryWin32HandleInfoKHR;
685  struct ExportMemoryWin32HandleInfoKHR;
686  struct MemoryWin32HandlePropertiesKHR;
687  struct MemoryGetWin32HandleInfoKHR;
688 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
689 
690  //=== VK_KHR_external_memory_fd ===
691  struct ImportMemoryFdInfoKHR;
692  struct MemoryFdPropertiesKHR;
693  struct MemoryGetFdInfoKHR;
694 
695 #if defined( VK_USE_PLATFORM_WIN32_KHR )
696  //=== VK_KHR_win32_keyed_mutex ===
697  struct Win32KeyedMutexAcquireReleaseInfoKHR;
698 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
699 
700 #if defined( VK_USE_PLATFORM_WIN32_KHR )
701  //=== VK_KHR_external_semaphore_win32 ===
702  struct ImportSemaphoreWin32HandleInfoKHR;
703  struct ExportSemaphoreWin32HandleInfoKHR;
704  struct D3D12FenceSubmitInfoKHR;
705  struct SemaphoreGetWin32HandleInfoKHR;
706 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
707 
708  //=== VK_KHR_external_semaphore_fd ===
710  struct SemaphoreGetFdInfoKHR;
711 
712  //=== VK_KHR_push_descriptor ===
714 
715  //=== VK_EXT_conditional_rendering ===
719 
720  //=== VK_KHR_incremental_present ===
721  struct PresentRegionsKHR;
722  struct PresentRegionKHR;
723  struct RectLayerKHR;
724 
725  //=== VK_NV_clip_space_w_scaling ===
726  struct ViewportWScalingNV;
728 
729  //=== VK_EXT_display_surface_counter ===
731 
732  //=== VK_EXT_display_control ===
733  struct DisplayPowerInfoEXT;
734  struct DeviceEventInfoEXT;
735  struct DisplayEventInfoEXT;
737 
738  //=== VK_GOOGLE_display_timing ===
741  struct PresentTimesInfoGOOGLE;
742  struct PresentTimeGOOGLE;
743 
744  //=== VK_NVX_multiview_per_view_attributes ===
746 
747  //=== VK_NV_viewport_swizzle ===
748  struct ViewportSwizzleNV;
750 
751  //=== VK_EXT_discard_rectangles ===
754 
755  //=== VK_EXT_conservative_rasterization ===
758 
759  //=== VK_EXT_depth_clip_enable ===
762 
763  //=== VK_EXT_hdr_metadata ===
764  struct HdrMetadataEXT;
765  struct XYColorEXT;
766 
767  //=== VK_KHR_shared_presentable_image ===
769 
770 #if defined( VK_USE_PLATFORM_WIN32_KHR )
771  //=== VK_KHR_external_fence_win32 ===
772  struct ImportFenceWin32HandleInfoKHR;
773  struct ExportFenceWin32HandleInfoKHR;
774  struct FenceGetWin32HandleInfoKHR;
775 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
776 
777  //=== VK_KHR_external_fence_fd ===
778  struct ImportFenceFdInfoKHR;
779  struct FenceGetFdInfoKHR;
780 
781  //=== VK_KHR_performance_query ===
784  struct PerformanceCounterKHR;
790 
791  //=== VK_KHR_get_surface_capabilities2 ===
794  struct SurfaceFormat2KHR;
795 
796  //=== VK_KHR_get_display_properties2 ===
797  struct DisplayProperties2KHR;
800  struct DisplayPlaneInfo2KHR;
802 
803 #if defined( VK_USE_PLATFORM_IOS_MVK )
804  //=== VK_MVK_ios_surface ===
805  struct IOSSurfaceCreateInfoMVK;
806 #endif /*VK_USE_PLATFORM_IOS_MVK*/
807 
808 #if defined( VK_USE_PLATFORM_MACOS_MVK )
809  //=== VK_MVK_macos_surface ===
810  struct MacOSSurfaceCreateInfoMVK;
811 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
812 
813  //=== VK_EXT_debug_utils ===
814  struct DebugUtilsLabelEXT;
819 
820 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
821  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
822  struct AndroidHardwareBufferUsageANDROID;
823  struct AndroidHardwareBufferPropertiesANDROID;
824  struct AndroidHardwareBufferFormatPropertiesANDROID;
825  struct ImportAndroidHardwareBufferInfoANDROID;
826  struct MemoryGetAndroidHardwareBufferInfoANDROID;
827  struct ExternalFormatANDROID;
828  struct AndroidHardwareBufferFormatProperties2ANDROID;
829 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
830 
831  //=== VK_EXT_sample_locations ===
832  struct SampleLocationEXT;
833  struct SampleLocationsInfoEXT;
840 
841  //=== VK_EXT_blend_operation_advanced ===
845 
846  //=== VK_NV_fragment_coverage_to_color ===
848 
849  //=== VK_KHR_acceleration_structure ===
853  struct AabbPositionsKHR;
856  struct TransformMatrixKHR;
875 
876  //=== VK_NV_framebuffer_mixed_samples ===
878 
879  //=== VK_NV_shader_sm_builtins ===
882 
883  //=== VK_EXT_image_drm_format_modifier ===
892 
893  //=== VK_EXT_validation_cache ===
896 
897 #if defined( VK_ENABLE_BETA_EXTENSIONS )
898  //=== VK_KHR_portability_subset ===
899  struct PhysicalDevicePortabilitySubsetFeaturesKHR;
900  struct PhysicalDevicePortabilitySubsetPropertiesKHR;
901 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
902 
903  //=== VK_NV_shading_rate_image ===
904  struct ShadingRatePaletteNV;
908  struct CoarseSampleLocationNV;
911 
912  //=== VK_NV_ray_tracing ===
915  struct GeometryTrianglesNV;
916  struct GeometryAABBNV;
917  struct GeometryDataNV;
918  struct GeometryNV;
925 
926  //=== VK_NV_representative_fragment_test ===
929 
930  //=== VK_EXT_filter_cubic ===
933 
934  //=== VK_EXT_external_memory_host ===
938 
939  //=== VK_KHR_shader_clock ===
941 
942  //=== VK_AMD_pipeline_compiler_control ===
944 
945  //=== VK_EXT_calibrated_timestamps ===
947 
948  //=== VK_AMD_shader_core_properties ===
950 
951 #if defined( VK_ENABLE_BETA_EXTENSIONS )
952  //=== VK_EXT_video_decode_h265 ===
953  struct VideoDecodeH265ProfileInfoEXT;
954  struct VideoDecodeH265CapabilitiesEXT;
955  struct VideoDecodeH265SessionParametersCreateInfoEXT;
956  struct VideoDecodeH265SessionParametersAddInfoEXT;
957  struct VideoDecodeH265PictureInfoEXT;
958  struct VideoDecodeH265DpbSlotInfoEXT;
959 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
960 
961  //=== VK_KHR_global_priority ===
968 
969  //=== VK_AMD_memory_overallocation_behavior ===
971 
972  //=== VK_EXT_vertex_attribute_divisor ===
977 
978 #if defined( VK_USE_PLATFORM_GGP )
979  //=== VK_GGP_frame_token ===
980  struct PresentFrameTokenGGP;
981 #endif /*VK_USE_PLATFORM_GGP*/
982 
983  //=== VK_NV_compute_shader_derivatives ===
985 
986  //=== VK_NV_mesh_shader ===
990 
991  //=== VK_NV_shader_image_footprint ===
993 
994  //=== VK_NV_scissor_exclusive ===
997 
998  //=== VK_NV_device_diagnostic_checkpoints ===
1000  struct CheckpointDataNV;
1001 
1002  //=== VK_INTEL_shader_integer_functions2 ===
1004 
1005  //=== VK_INTEL_performance_query ===
1007  struct PerformanceValueINTEL;
1015 
1016  //=== VK_EXT_pci_bus_info ===
1018 
1019  //=== VK_AMD_display_native_hdr ===
1022 
1023 #if defined( VK_USE_PLATFORM_FUCHSIA )
1024  //=== VK_FUCHSIA_imagepipe_surface ===
1025  struct ImagePipeSurfaceCreateInfoFUCHSIA;
1026 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1027 
1028 #if defined( VK_USE_PLATFORM_METAL_EXT )
1029  //=== VK_EXT_metal_surface ===
1030  struct MetalSurfaceCreateInfoEXT;
1031 #endif /*VK_USE_PLATFORM_METAL_EXT*/
1032 
1033  //=== VK_EXT_fragment_density_map ===
1037 
1038  //=== VK_KHR_fragment_shading_rate ===
1044 
1045  //=== VK_AMD_shader_core_properties2 ===
1047 
1048  //=== VK_AMD_device_coherent_memory ===
1050 
1051  //=== VK_EXT_shader_image_atomic_int64 ===
1053 
1054  //=== VK_EXT_memory_budget ===
1056 
1057  //=== VK_EXT_memory_priority ===
1060 
1061  //=== VK_KHR_surface_protected_capabilities ===
1063 
1064  //=== VK_NV_dedicated_allocation_image_aliasing ===
1066 
1067  //=== VK_EXT_buffer_device_address ===
1071 
1072  //=== VK_EXT_validation_features ===
1073  struct ValidationFeaturesEXT;
1074 
1075  //=== VK_KHR_present_wait ===
1077 
1078  //=== VK_NV_cooperative_matrix ===
1082 
1083  //=== VK_NV_coverage_reduction_mode ===
1087 
1088  //=== VK_EXT_fragment_shader_interlock ===
1090 
1091  //=== VK_EXT_ycbcr_image_arrays ===
1093 
1094  //=== VK_EXT_provoking_vertex ===
1098 
1099 #if defined( VK_USE_PLATFORM_WIN32_KHR )
1100  //=== VK_EXT_full_screen_exclusive ===
1101  struct SurfaceFullScreenExclusiveInfoEXT;
1102  struct SurfaceCapabilitiesFullScreenExclusiveEXT;
1103  struct SurfaceFullScreenExclusiveWin32InfoEXT;
1104 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
1105 
1106  //=== VK_EXT_headless_surface ===
1108 
1109  //=== VK_EXT_line_rasterization ===
1113 
1114  //=== VK_EXT_shader_atomic_float ===
1116 
1117  //=== VK_EXT_index_type_uint8 ===
1119 
1120  //=== VK_EXT_extended_dynamic_state ===
1122 
1123  //=== VK_KHR_pipeline_executable_properties ===
1125  struct PipelineInfoKHR;
1132 
1133  //=== VK_EXT_shader_atomic_float2 ===
1135 
1136  //=== VK_NV_device_generated_commands ===
1145  struct IndirectCommandsStreamNV;
1148  struct GeneratedCommandsInfoNV;
1150 
1151  //=== VK_NV_inherited_viewport_scissor ===
1154 
1155  //=== VK_EXT_texel_buffer_alignment ===
1157 
1158  //=== VK_QCOM_render_pass_transform ===
1161 
1162  //=== VK_EXT_device_memory_report ===
1166 
1167  //=== VK_EXT_robustness2 ===
1170 
1171  //=== VK_EXT_custom_border_color ===
1175 
1176  //=== VK_KHR_pipeline_library ===
1178 
1179  //=== VK_NV_present_barrier ===
1183 
1184  //=== VK_KHR_present_id ===
1185  struct PresentIdKHR;
1187 
1188 #if defined( VK_ENABLE_BETA_EXTENSIONS )
1189  //=== VK_KHR_video_encode_queue ===
1190  struct VideoEncodeInfoKHR;
1191  struct VideoEncodeCapabilitiesKHR;
1192  struct VideoEncodeUsageInfoKHR;
1193  struct VideoEncodeRateControlInfoKHR;
1194  struct VideoEncodeRateControlLayerInfoKHR;
1195 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
1196 
1197  //=== VK_NV_device_diagnostics_config ===
1200 
1201 #if defined( VK_USE_PLATFORM_METAL_EXT )
1202  //=== VK_EXT_metal_objects ===
1203  struct ExportMetalObjectCreateInfoEXT;
1204  struct ExportMetalObjectsInfoEXT;
1205  struct ExportMetalDeviceInfoEXT;
1206  struct ExportMetalCommandQueueInfoEXT;
1207  struct ExportMetalBufferInfoEXT;
1208  struct ImportMetalBufferInfoEXT;
1209  struct ExportMetalTextureInfoEXT;
1210  struct ImportMetalTextureInfoEXT;
1211  struct ExportMetalIOSurfaceInfoEXT;
1212  struct ImportMetalIOSurfaceInfoEXT;
1213  struct ExportMetalSharedEventInfoEXT;
1214  struct ImportMetalSharedEventInfoEXT;
1215 #endif /*VK_USE_PLATFORM_METAL_EXT*/
1216 
1217  //=== VK_KHR_synchronization2 ===
1219  struct CheckpointData2NV;
1220 
1221  //=== VK_EXT_descriptor_buffer ===
1225  struct DescriptorAddressInfoEXT;
1228  union DescriptorDataEXT;
1229  struct DescriptorGetInfoEXT;
1236 
1237  //=== VK_EXT_graphics_pipeline_library ===
1241 
1242  //=== VK_AMD_shader_early_and_late_fragment_tests ===
1244 
1245  //=== VK_KHR_fragment_shader_barycentric ===
1249 
1250  //=== VK_KHR_shader_subgroup_uniform_control_flow ===
1252 
1253  //=== VK_NV_fragment_shading_rate_enums ===
1257 
1258  //=== VK_NV_ray_tracing_motion_blur ===
1265  struct SRTDataNV;
1267 
1268  //=== VK_EXT_mesh_shader ===
1272 
1273  //=== VK_EXT_ycbcr_2plane_444_formats ===
1275 
1276  //=== VK_EXT_fragment_density_map2 ===
1279 
1280  //=== VK_QCOM_rotated_copy_commands ===
1282 
1283  //=== VK_KHR_workgroup_memory_explicit_layout ===
1285 
1286  //=== VK_EXT_image_compression_control ===
1289  struct SubresourceLayout2EXT;
1290  struct ImageSubresource2EXT;
1292 
1293  //=== VK_EXT_attachment_feedback_loop_layout ===
1295 
1296  //=== VK_EXT_4444_formats ===
1298 
1299  //=== VK_EXT_device_fault ===
1301  struct DeviceFaultCountsEXT;
1302  struct DeviceFaultInfoEXT;
1304  struct DeviceFaultVendorInfoEXT;
1306 
1307  //=== VK_EXT_rgba10x6_formats ===
1309 
1310 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
1311  //=== VK_EXT_directfb_surface ===
1312  struct DirectFBSurfaceCreateInfoEXT;
1313 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
1314 
1315  //=== VK_KHR_ray_tracing_pipeline ===
1323 
1324  //=== VK_KHR_ray_query ===
1326 
1327  //=== VK_EXT_vertex_input_dynamic_state ===
1331 
1332  //=== VK_EXT_physical_device_drm ===
1334 
1335  //=== VK_EXT_device_address_binding_report ===
1338 
1339  //=== VK_EXT_depth_clip_control ===
1342 
1343  //=== VK_EXT_primitive_topology_list_restart ===
1345 
1346 #if defined( VK_USE_PLATFORM_FUCHSIA )
1347  //=== VK_FUCHSIA_external_memory ===
1348  struct ImportMemoryZirconHandleInfoFUCHSIA;
1349  struct MemoryZirconHandlePropertiesFUCHSIA;
1350  struct MemoryGetZirconHandleInfoFUCHSIA;
1351 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1352 
1353 #if defined( VK_USE_PLATFORM_FUCHSIA )
1354  //=== VK_FUCHSIA_external_semaphore ===
1355  struct ImportSemaphoreZirconHandleInfoFUCHSIA;
1356  struct SemaphoreGetZirconHandleInfoFUCHSIA;
1357 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1358 
1359 #if defined( VK_USE_PLATFORM_FUCHSIA )
1360  //=== VK_FUCHSIA_buffer_collection ===
1361  struct BufferCollectionCreateInfoFUCHSIA;
1362  struct ImportMemoryBufferCollectionFUCHSIA;
1363  struct BufferCollectionImageCreateInfoFUCHSIA;
1364  struct BufferConstraintsInfoFUCHSIA;
1365  struct BufferCollectionBufferCreateInfoFUCHSIA;
1366  struct BufferCollectionPropertiesFUCHSIA;
1367  struct SysmemColorSpaceFUCHSIA;
1368  struct ImageConstraintsInfoFUCHSIA;
1369  struct ImageFormatConstraintsInfoFUCHSIA;
1370  struct BufferCollectionConstraintsInfoFUCHSIA;
1371 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1372 
1373  //=== VK_HUAWEI_subpass_shading ===
1377 
1378  //=== VK_HUAWEI_invocation_mask ===
1380 
1381  //=== VK_NV_external_memory_rdma ===
1384 
1385  //=== VK_EXT_pipeline_properties ===
1388 
1389  //=== VK_EXT_multisampled_render_to_single_sampled ===
1393 
1394  //=== VK_EXT_extended_dynamic_state2 ===
1396 
1397 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
1398  //=== VK_QNX_screen_surface ===
1399  struct ScreenSurfaceCreateInfoQNX;
1400 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
1401 
1402  //=== VK_EXT_color_write_enable ===
1405 
1406  //=== VK_EXT_primitives_generated_query ===
1408 
1409  //=== VK_KHR_ray_tracing_maintenance1 ===
1412 
1413  //=== VK_EXT_image_view_min_lod ===
1416 
1417  //=== VK_EXT_multi_draw ===
1420  struct MultiDrawInfoEXT;
1421  struct MultiDrawIndexedInfoEXT;
1422 
1423  //=== VK_EXT_image_2d_view_of_3d ===
1425 
1426  //=== VK_EXT_opacity_micromap ===
1427  struct MicromapBuildInfoEXT;
1428  struct MicromapUsageEXT;
1429  struct MicromapCreateInfoEXT;
1432  struct MicromapVersionInfoEXT;
1435  struct CopyMicromapInfoEXT;
1438  struct MicromapTriangleEXT;
1439 
1440  //=== VK_EXT_border_color_swizzle ===
1443 
1444  //=== VK_EXT_pageable_device_local_memory ===
1446 
1447  //=== VK_VALVE_descriptor_set_host_mapping ===
1451 
1452  //=== VK_EXT_depth_clamp_zero_one ===
1454 
1455  //=== VK_EXT_non_seamless_cube_map ===
1457 
1458  //=== VK_QCOM_fragment_density_map_offset ===
1462 
1463  //=== VK_NV_copy_memory_indirect ===
1468 
1469  //=== VK_NV_memory_decompression ===
1470  struct DecompressMemoryRegionNV;
1473 
1474  //=== VK_NV_linear_color_attachment ===
1476 
1477  //=== VK_EXT_image_compression_control_swapchain ===
1479 
1480  //=== VK_QCOM_image_processing ===
1484 
1485  //=== VK_EXT_extended_dynamic_state3 ===
1488  struct ColorBlendEquationEXT;
1489  struct ColorBlendAdvancedEXT;
1490 
1491  //=== VK_EXT_subpass_merge_feedback ===
1498 
1499  //=== VK_LUNARG_direct_driver_loading ===
1502 
1503  //=== VK_EXT_shader_module_identifier ===
1508 
1509  //=== VK_EXT_rasterization_order_attachment_access ===
1512 
1513  //=== VK_NV_optical_flow ===
1520  struct OpticalFlowExecuteInfoNV;
1521 
1522  //=== VK_EXT_legacy_dithering ===
1524 
1525  //=== VK_EXT_pipeline_protected_access ===
1527 
1528  //=== VK_QCOM_tile_properties ===
1530  struct TilePropertiesQCOM;
1531 
1532  //=== VK_SEC_amigo_profiling ===
1535 
1536  //=== VK_QCOM_multiview_per_view_viewports ===
1538 
1539  //=== VK_NV_ray_tracing_invocation_reorder ===
1542 
1543  //=== VK_EXT_mutable_descriptor_type ===
1550 
1551  //=== VK_ARM_shader_core_builtins ===
1554 
1555  //===============
1556  //=== HANDLEs ===
1557  //===============
1558 
1559  template <typename Type>
1561  {
1563  };
1564 
1566  {
1567  public:
1568  using CType = VkSurfaceKHR;
1569  using NativeType = VkSurfaceKHR;
1570 
1574 
1575  public:
1576  VULKAN_HPP_CONSTEXPR SurfaceKHR() = default;
1578  VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( surfaceKHR ) {}
1579 
1580 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
1581  SurfaceKHR & operator=( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT
1582  {
1583  m_surfaceKHR = surfaceKHR;
1584  return *this;
1585  }
1586 #endif
1587 
1589  {
1590  m_surfaceKHR = {};
1591  return *this;
1592  }
1593 
1594 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1595  auto operator<=>( SurfaceKHR const & ) const = default;
1596 #else
1597  bool operator==( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1598  {
1599  return m_surfaceKHR == rhs.m_surfaceKHR;
1600  }
1601 
1602  bool operator!=( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1603  {
1604  return m_surfaceKHR != rhs.m_surfaceKHR;
1605  }
1606 
1607  bool operator<( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1608  {
1609  return m_surfaceKHR < rhs.m_surfaceKHR;
1610  }
1611 #endif
1612 
1614  {
1615  return m_surfaceKHR;
1616  }
1617 
1618  explicit operator bool() const VULKAN_HPP_NOEXCEPT
1619  {
1620  return m_surfaceKHR != VK_NULL_HANDLE;
1621  }
1622 
1624  {
1625  return m_surfaceKHR == VK_NULL_HANDLE;
1626  }
1627 
1628  private:
1629  VkSurfaceKHR m_surfaceKHR = {};
1630  };
1631 
1632  template <>
1634  {
1636  };
1637 
1638  template <>
1640  {
1642  };
1643 
1644  template <>
1646  {
1648  };
1649 
1651  {
1652  public:
1653  using CType = VkDebugReportCallbackEXT;
1654  using NativeType = VkDebugReportCallbackEXT;
1655 
1659 
1660  public:
1663  VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
1664  : m_debugReportCallbackEXT( debugReportCallbackEXT )
1665  {
1666  }
1667 
1668 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
1669  DebugReportCallbackEXT & operator=( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
1670  {
1671  m_debugReportCallbackEXT = debugReportCallbackEXT;
1672  return *this;
1673  }
1674 #endif
1675 
1677  {
1678  m_debugReportCallbackEXT = {};
1679  return *this;
1680  }
1681 
1682 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1683  auto operator<=>( DebugReportCallbackEXT const & ) const = default;
1684 #else
1686  {
1687  return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;
1688  }
1689 
1691  {
1692  return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;
1693  }
1694 
1696  {
1697  return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;
1698  }
1699 #endif
1700 
1701  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT
1702  {
1703  return m_debugReportCallbackEXT;
1704  }
1705 
1706  explicit operator bool() const VULKAN_HPP_NOEXCEPT
1707  {
1708  return m_debugReportCallbackEXT != VK_NULL_HANDLE;
1709  }
1710 
1712  {
1713  return m_debugReportCallbackEXT == VK_NULL_HANDLE;
1714  }
1715 
1716  private:
1717  VkDebugReportCallbackEXT m_debugReportCallbackEXT = {};
1718  };
1719 
1720  template <>
1722  {
1724  };
1725 
1726  template <>
1728  {
1730  };
1731 
1732  template <>
1734  {
1736  };
1737 
1739  {
1740  public:
1741  using CType = VkDebugUtilsMessengerEXT;
1742  using NativeType = VkDebugUtilsMessengerEXT;
1743 
1747 
1748  public:
1751  VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
1752  : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
1753  {
1754  }
1755 
1756 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
1757  DebugUtilsMessengerEXT & operator=( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
1758  {
1759  m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
1760  return *this;
1761  }
1762 #endif
1763 
1765  {
1766  m_debugUtilsMessengerEXT = {};
1767  return *this;
1768  }
1769 
1770 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1771  auto operator<=>( DebugUtilsMessengerEXT const & ) const = default;
1772 #else
1774  {
1775  return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT;
1776  }
1777 
1779  {
1780  return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT;
1781  }
1782 
1784  {
1785  return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT;
1786  }
1787 #endif
1788 
1789  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT
1790  {
1791  return m_debugUtilsMessengerEXT;
1792  }
1793 
1794  explicit operator bool() const VULKAN_HPP_NOEXCEPT
1795  {
1796  return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;
1797  }
1798 
1800  {
1801  return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;
1802  }
1803 
1804  private:
1805  VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};
1806  };
1807 
1808  template <>
1810  {
1812  };
1813 
1814  template <>
1816  {
1818  };
1819 
1821  {
1822  public:
1823  using CType = VkDisplayKHR;
1824  using NativeType = VkDisplayKHR;
1825 
1829 
1830  public:
1831  VULKAN_HPP_CONSTEXPR DisplayKHR() = default;
1833  VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR ) {}
1834 
1835 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
1836  DisplayKHR & operator=( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT
1837  {
1838  m_displayKHR = displayKHR;
1839  return *this;
1840  }
1841 #endif
1842 
1844  {
1845  m_displayKHR = {};
1846  return *this;
1847  }
1848 
1849 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1850  auto operator<=>( DisplayKHR const & ) const = default;
1851 #else
1852  bool operator==( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1853  {
1854  return m_displayKHR == rhs.m_displayKHR;
1855  }
1856 
1857  bool operator!=( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1858  {
1859  return m_displayKHR != rhs.m_displayKHR;
1860  }
1861 
1862  bool operator<( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1863  {
1864  return m_displayKHR < rhs.m_displayKHR;
1865  }
1866 #endif
1867 
1869  {
1870  return m_displayKHR;
1871  }
1872 
1873  explicit operator bool() const VULKAN_HPP_NOEXCEPT
1874  {
1875  return m_displayKHR != VK_NULL_HANDLE;
1876  }
1877 
1879  {
1880  return m_displayKHR == VK_NULL_HANDLE;
1881  }
1882 
1883  private:
1884  VkDisplayKHR m_displayKHR = {};
1885  };
1886 
1887  template <>
1889  {
1891  };
1892 
1893  template <>
1895  {
1897  };
1898 
1899  template <>
1901  {
1903  };
1904 
1906  {
1907  public:
1908  using CType = VkSwapchainKHR;
1909  using NativeType = VkSwapchainKHR;
1910 
1914 
1915  public:
1916  VULKAN_HPP_CONSTEXPR SwapchainKHR() = default;
1918  VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( swapchainKHR ) {}
1919 
1920 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
1921  SwapchainKHR & operator=( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
1922  {
1923  m_swapchainKHR = swapchainKHR;
1924  return *this;
1925  }
1926 #endif
1927 
1929  {
1930  m_swapchainKHR = {};
1931  return *this;
1932  }
1933 
1934 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1935  auto operator<=>( SwapchainKHR const & ) const = default;
1936 #else
1937  bool operator==( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1938  {
1939  return m_swapchainKHR == rhs.m_swapchainKHR;
1940  }
1941 
1942  bool operator!=( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1943  {
1944  return m_swapchainKHR != rhs.m_swapchainKHR;
1945  }
1946 
1947  bool operator<( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1948  {
1949  return m_swapchainKHR < rhs.m_swapchainKHR;
1950  }
1951 #endif
1952 
1953  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT
1954  {
1955  return m_swapchainKHR;
1956  }
1957 
1958  explicit operator bool() const VULKAN_HPP_NOEXCEPT
1959  {
1960  return m_swapchainKHR != VK_NULL_HANDLE;
1961  }
1962 
1964  {
1965  return m_swapchainKHR == VK_NULL_HANDLE;
1966  }
1967 
1968  private:
1969  VkSwapchainKHR m_swapchainKHR = {};
1970  };
1971 
1972  template <>
1974  {
1976  };
1977 
1978  template <>
1980  {
1982  };
1983 
1984  template <>
1986  {
1988  };
1989 
1991  {
1992  public:
1993  using CType = VkSemaphore;
1994  using NativeType = VkSemaphore;
1995 
1999 
2000  public:
2001  VULKAN_HPP_CONSTEXPR Semaphore() = default;
2003  VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT : m_semaphore( semaphore ) {}
2004 
2005 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2006  Semaphore & operator=( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT
2007  {
2008  m_semaphore = semaphore;
2009  return *this;
2010  }
2011 #endif
2012 
2014  {
2015  m_semaphore = {};
2016  return *this;
2017  }
2018 
2019 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2020  auto operator<=>( Semaphore const & ) const = default;
2021 #else
2022  bool operator==( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2023  {
2024  return m_semaphore == rhs.m_semaphore;
2025  }
2026 
2027  bool operator!=( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2028  {
2029  return m_semaphore != rhs.m_semaphore;
2030  }
2031 
2032  bool operator<( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2033  {
2034  return m_semaphore < rhs.m_semaphore;
2035  }
2036 #endif
2037 
2039  {
2040  return m_semaphore;
2041  }
2042 
2043  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2044  {
2045  return m_semaphore != VK_NULL_HANDLE;
2046  }
2047 
2049  {
2050  return m_semaphore == VK_NULL_HANDLE;
2051  }
2052 
2053  private:
2054  VkSemaphore m_semaphore = {};
2055  };
2056 
2057  template <>
2059  {
2061  };
2062 
2063  template <>
2065  {
2067  };
2068 
2069  template <>
2071  {
2073  };
2074 
2075  class Fence
2076  {
2077  public:
2078  using CType = VkFence;
2079  using NativeType = VkFence;
2080 
2084 
2085  public:
2086  VULKAN_HPP_CONSTEXPR Fence() = default;
2088  VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT : m_fence( fence ) {}
2089 
2090 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2091  Fence & operator=( VkFence fence ) VULKAN_HPP_NOEXCEPT
2092  {
2093  m_fence = fence;
2094  return *this;
2095  }
2096 #endif
2097 
2099  {
2100  m_fence = {};
2101  return *this;
2102  }
2103 
2104 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2105  auto operator<=>( Fence const & ) const = default;
2106 #else
2107  bool operator==( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
2108  {
2109  return m_fence == rhs.m_fence;
2110  }
2111 
2112  bool operator!=( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
2113  {
2114  return m_fence != rhs.m_fence;
2115  }
2116 
2117  bool operator<( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
2118  {
2119  return m_fence < rhs.m_fence;
2120  }
2121 #endif
2122 
2124  {
2125  return m_fence;
2126  }
2127 
2128  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2129  {
2130  return m_fence != VK_NULL_HANDLE;
2131  }
2132 
2134  {
2135  return m_fence == VK_NULL_HANDLE;
2136  }
2137 
2138  private:
2139  VkFence m_fence = {};
2140  };
2141 
2142  template <>
2144  {
2146  };
2147 
2148  template <>
2150  {
2152  };
2153 
2154  template <>
2156  {
2158  };
2159 
2161  {
2162  public:
2163  using CType = VkPerformanceConfigurationINTEL;
2164  using NativeType = VkPerformanceConfigurationINTEL;
2165 
2169 
2170  public:
2173  VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
2174  : m_performanceConfigurationINTEL( performanceConfigurationINTEL )
2175  {
2176  }
2177 
2178 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2179  PerformanceConfigurationINTEL & operator=( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
2180  {
2181  m_performanceConfigurationINTEL = performanceConfigurationINTEL;
2182  return *this;
2183  }
2184 #endif
2185 
2187  {
2188  m_performanceConfigurationINTEL = {};
2189  return *this;
2190  }
2191 
2192 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2193  auto operator<=>( PerformanceConfigurationINTEL const & ) const = default;
2194 #else
2196  {
2197  return m_performanceConfigurationINTEL == rhs.m_performanceConfigurationINTEL;
2198  }
2199 
2201  {
2202  return m_performanceConfigurationINTEL != rhs.m_performanceConfigurationINTEL;
2203  }
2204 
2206  {
2207  return m_performanceConfigurationINTEL < rhs.m_performanceConfigurationINTEL;
2208  }
2209 #endif
2210 
2211  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT
2212  {
2213  return m_performanceConfigurationINTEL;
2214  }
2215 
2216  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2217  {
2218  return m_performanceConfigurationINTEL != VK_NULL_HANDLE;
2219  }
2220 
2222  {
2223  return m_performanceConfigurationINTEL == VK_NULL_HANDLE;
2224  }
2225 
2226  private:
2227  VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {};
2228  };
2229 
2230  template <>
2232  {
2234  };
2235 
2236  template <>
2238  {
2240  };
2241 
2243  {
2244  public:
2245  using CType = VkQueryPool;
2246  using NativeType = VkQueryPool;
2247 
2251 
2252  public:
2253  VULKAN_HPP_CONSTEXPR QueryPool() = default;
2255  VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT : m_queryPool( queryPool ) {}
2256 
2257 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2258  QueryPool & operator=( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT
2259  {
2260  m_queryPool = queryPool;
2261  return *this;
2262  }
2263 #endif
2264 
2266  {
2267  m_queryPool = {};
2268  return *this;
2269  }
2270 
2271 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2272  auto operator<=>( QueryPool const & ) const = default;
2273 #else
2274  bool operator==( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
2275  {
2276  return m_queryPool == rhs.m_queryPool;
2277  }
2278 
2279  bool operator!=( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
2280  {
2281  return m_queryPool != rhs.m_queryPool;
2282  }
2283 
2284  bool operator<( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
2285  {
2286  return m_queryPool < rhs.m_queryPool;
2287  }
2288 #endif
2289 
2291  {
2292  return m_queryPool;
2293  }
2294 
2295  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2296  {
2297  return m_queryPool != VK_NULL_HANDLE;
2298  }
2299 
2301  {
2302  return m_queryPool == VK_NULL_HANDLE;
2303  }
2304 
2305  private:
2306  VkQueryPool m_queryPool = {};
2307  };
2308 
2309  template <>
2311  {
2313  };
2314 
2315  template <>
2317  {
2319  };
2320 
2321  template <>
2323  {
2325  };
2326 
2327  class Buffer
2328  {
2329  public:
2330  using CType = VkBuffer;
2331  using NativeType = VkBuffer;
2332 
2336 
2337  public:
2338  VULKAN_HPP_CONSTEXPR Buffer() = default;
2341 
2342 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2344  {
2345  m_buffer = buffer;
2346  return *this;
2347  }
2348 #endif
2349 
2351  {
2352  m_buffer = {};
2353  return *this;
2354  }
2355 
2356 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2357  auto operator<=>( Buffer const & ) const = default;
2358 #else
2359  bool operator==( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
2360  {
2361  return m_buffer == rhs.m_buffer;
2362  }
2363 
2364  bool operator!=( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
2365  {
2366  return m_buffer != rhs.m_buffer;
2367  }
2368 
2369  bool operator<( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
2370  {
2371  return m_buffer < rhs.m_buffer;
2372  }
2373 #endif
2374 
2376  {
2377  return m_buffer;
2378  }
2379 
2380  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2381  {
2382  return m_buffer != VK_NULL_HANDLE;
2383  }
2384 
2386  {
2387  return m_buffer == VK_NULL_HANDLE;
2388  }
2389 
2390  private:
2391  VkBuffer m_buffer = {};
2392  };
2393 
2394  template <>
2396  {
2398  };
2399 
2400  template <>
2402  {
2404  };
2405 
2406  template <>
2408  {
2410  };
2411 
2413  {
2414  public:
2415  using CType = VkPipelineLayout;
2416  using NativeType = VkPipelineLayout;
2417 
2421 
2422  public:
2425  VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( pipelineLayout ) {}
2426 
2427 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2428  PipelineLayout & operator=( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
2429  {
2430  m_pipelineLayout = pipelineLayout;
2431  return *this;
2432  }
2433 #endif
2434 
2436  {
2437  m_pipelineLayout = {};
2438  return *this;
2439  }
2440 
2441 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2442  auto operator<=>( PipelineLayout const & ) const = default;
2443 #else
2445  {
2446  return m_pipelineLayout == rhs.m_pipelineLayout;
2447  }
2448 
2450  {
2451  return m_pipelineLayout != rhs.m_pipelineLayout;
2452  }
2453 
2455  {
2456  return m_pipelineLayout < rhs.m_pipelineLayout;
2457  }
2458 #endif
2459 
2460  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT
2461  {
2462  return m_pipelineLayout;
2463  }
2464 
2465  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2466  {
2467  return m_pipelineLayout != VK_NULL_HANDLE;
2468  }
2469 
2471  {
2472  return m_pipelineLayout == VK_NULL_HANDLE;
2473  }
2474 
2475  private:
2476  VkPipelineLayout m_pipelineLayout = {};
2477  };
2478 
2479  template <>
2481  {
2483  };
2484 
2485  template <>
2487  {
2489  };
2490 
2491  template <>
2493  {
2495  };
2496 
2498  {
2499  public:
2500  using CType = VkDescriptorSet;
2501  using NativeType = VkDescriptorSet;
2502 
2506 
2507  public:
2508  VULKAN_HPP_CONSTEXPR DescriptorSet() = default;
2510  VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( descriptorSet ) {}
2511 
2512 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2513  DescriptorSet & operator=( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
2514  {
2515  m_descriptorSet = descriptorSet;
2516  return *this;
2517  }
2518 #endif
2519 
2521  {
2522  m_descriptorSet = {};
2523  return *this;
2524  }
2525 
2526 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2527  auto operator<=>( DescriptorSet const & ) const = default;
2528 #else
2530  {
2531  return m_descriptorSet == rhs.m_descriptorSet;
2532  }
2533 
2535  {
2536  return m_descriptorSet != rhs.m_descriptorSet;
2537  }
2538 
2539  bool operator<( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2540  {
2541  return m_descriptorSet < rhs.m_descriptorSet;
2542  }
2543 #endif
2544 
2545  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT
2546  {
2547  return m_descriptorSet;
2548  }
2549 
2550  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2551  {
2552  return m_descriptorSet != VK_NULL_HANDLE;
2553  }
2554 
2556  {
2557  return m_descriptorSet == VK_NULL_HANDLE;
2558  }
2559 
2560  private:
2561  VkDescriptorSet m_descriptorSet = {};
2562  };
2563 
2564  template <>
2566  {
2568  };
2569 
2570  template <>
2572  {
2574  };
2575 
2576  template <>
2578  {
2580  };
2581 
2583  {
2584  public:
2585  using CType = VkImageView;
2586  using NativeType = VkImageView;
2587 
2591 
2592  public:
2593  VULKAN_HPP_CONSTEXPR ImageView() = default;
2595  VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT : m_imageView( imageView ) {}
2596 
2597 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2598  ImageView & operator=( VkImageView imageView ) VULKAN_HPP_NOEXCEPT
2599  {
2600  m_imageView = imageView;
2601  return *this;
2602  }
2603 #endif
2604 
2606  {
2607  m_imageView = {};
2608  return *this;
2609  }
2610 
2611 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2612  auto operator<=>( ImageView const & ) const = default;
2613 #else
2614  bool operator==( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
2615  {
2616  return m_imageView == rhs.m_imageView;
2617  }
2618 
2619  bool operator!=( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
2620  {
2621  return m_imageView != rhs.m_imageView;
2622  }
2623 
2624  bool operator<( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
2625  {
2626  return m_imageView < rhs.m_imageView;
2627  }
2628 #endif
2629 
2631  {
2632  return m_imageView;
2633  }
2634 
2635  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2636  {
2637  return m_imageView != VK_NULL_HANDLE;
2638  }
2639 
2641  {
2642  return m_imageView == VK_NULL_HANDLE;
2643  }
2644 
2645  private:
2646  VkImageView m_imageView = {};
2647  };
2648 
2649  template <>
2651  {
2653  };
2654 
2655  template <>
2657  {
2659  };
2660 
2661  template <>
2663  {
2665  };
2666 
2667  class Pipeline
2668  {
2669  public:
2670  using CType = VkPipeline;
2671  using NativeType = VkPipeline;
2672 
2676 
2677  public:
2678  VULKAN_HPP_CONSTEXPR Pipeline() = default;
2680  VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT : m_pipeline( pipeline ) {}
2681 
2682 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2683  Pipeline & operator=( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT
2684  {
2685  m_pipeline = pipeline;
2686  return *this;
2687  }
2688 #endif
2689 
2691  {
2692  m_pipeline = {};
2693  return *this;
2694  }
2695 
2696 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2697  auto operator<=>( Pipeline const & ) const = default;
2698 #else
2699  bool operator==( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
2700  {
2701  return m_pipeline == rhs.m_pipeline;
2702  }
2703 
2704  bool operator!=( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
2705  {
2706  return m_pipeline != rhs.m_pipeline;
2707  }
2708 
2709  bool operator<( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
2710  {
2711  return m_pipeline < rhs.m_pipeline;
2712  }
2713 #endif
2714 
2716  {
2717  return m_pipeline;
2718  }
2719 
2720  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2721  {
2722  return m_pipeline != VK_NULL_HANDLE;
2723  }
2724 
2726  {
2727  return m_pipeline == VK_NULL_HANDLE;
2728  }
2729 
2730  private:
2731  VkPipeline m_pipeline = {};
2732  };
2733 
2734  template <>
2736  {
2738  };
2739 
2740  template <>
2742  {
2744  };
2745 
2746  template <>
2748  {
2750  };
2751 
2752  class Image
2753  {
2754  public:
2755  using CType = VkImage;
2756  using NativeType = VkImage;
2757 
2761 
2762  public:
2763  VULKAN_HPP_CONSTEXPR Image() = default;
2766 
2767 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2769  {
2770  m_image = image;
2771  return *this;
2772  }
2773 #endif
2774 
2776  {
2777  m_image = {};
2778  return *this;
2779  }
2780 
2781 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2782  auto operator<=>( Image const & ) const = default;
2783 #else
2784  bool operator==( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
2785  {
2786  return m_image == rhs.m_image;
2787  }
2788 
2789  bool operator!=( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
2790  {
2791  return m_image != rhs.m_image;
2792  }
2793 
2794  bool operator<( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
2795  {
2796  return m_image < rhs.m_image;
2797  }
2798 #endif
2799 
2801  {
2802  return m_image;
2803  }
2804 
2805  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2806  {
2807  return m_image != VK_NULL_HANDLE;
2808  }
2809 
2811  {
2812  return m_image == VK_NULL_HANDLE;
2813  }
2814 
2815  private:
2816  VkImage m_image = {};
2817  };
2818 
2819  template <>
2821  {
2823  };
2824 
2825  template <>
2827  {
2829  };
2830 
2831  template <>
2833  {
2835  };
2836 
2838  {
2839  public:
2840  using CType = VkAccelerationStructureNV;
2841  using NativeType = VkAccelerationStructureNV;
2842 
2846 
2847  public:
2850  VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
2851  : m_accelerationStructureNV( accelerationStructureNV )
2852  {
2853  }
2854 
2855 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2856  AccelerationStructureNV & operator=( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
2857  {
2858  m_accelerationStructureNV = accelerationStructureNV;
2859  return *this;
2860  }
2861 #endif
2862 
2864  {
2865  m_accelerationStructureNV = {};
2866  return *this;
2867  }
2868 
2869 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2870  auto operator<=>( AccelerationStructureNV const & ) const = default;
2871 #else
2873  {
2874  return m_accelerationStructureNV == rhs.m_accelerationStructureNV;
2875  }
2876 
2878  {
2879  return m_accelerationStructureNV != rhs.m_accelerationStructureNV;
2880  }
2881 
2883  {
2884  return m_accelerationStructureNV < rhs.m_accelerationStructureNV;
2885  }
2886 #endif
2887 
2888  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const VULKAN_HPP_NOEXCEPT
2889  {
2890  return m_accelerationStructureNV;
2891  }
2892 
2893  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2894  {
2895  return m_accelerationStructureNV != VK_NULL_HANDLE;
2896  }
2897 
2899  {
2900  return m_accelerationStructureNV == VK_NULL_HANDLE;
2901  }
2902 
2903  private:
2904  VkAccelerationStructureNV m_accelerationStructureNV = {};
2905  };
2906 
2907  template <>
2909  {
2911  };
2912 
2913  template <>
2915  {
2917  };
2918 
2919  template <>
2921  {
2923  };
2924 
2926  {
2927  public:
2928  using CType = VkOpticalFlowSessionNV;
2929  using NativeType = VkOpticalFlowSessionNV;
2930 
2934 
2935  public:
2938  VULKAN_HPP_TYPESAFE_EXPLICIT OpticalFlowSessionNV( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT
2939  : m_opticalFlowSessionNV( opticalFlowSessionNV )
2940  {
2941  }
2942 
2943 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2944  OpticalFlowSessionNV & operator=( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT
2945  {
2946  m_opticalFlowSessionNV = opticalFlowSessionNV;
2947  return *this;
2948  }
2949 #endif
2950 
2952  {
2953  m_opticalFlowSessionNV = {};
2954  return *this;
2955  }
2956 
2957 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2958  auto operator<=>( OpticalFlowSessionNV const & ) const = default;
2959 #else
2961  {
2962  return m_opticalFlowSessionNV == rhs.m_opticalFlowSessionNV;
2963  }
2964 
2966  {
2967  return m_opticalFlowSessionNV != rhs.m_opticalFlowSessionNV;
2968  }
2969 
2971  {
2972  return m_opticalFlowSessionNV < rhs.m_opticalFlowSessionNV;
2973  }
2974 #endif
2975 
2976  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkOpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT
2977  {
2978  return m_opticalFlowSessionNV;
2979  }
2980 
2981  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2982  {
2983  return m_opticalFlowSessionNV != VK_NULL_HANDLE;
2984  }
2985 
2987  {
2988  return m_opticalFlowSessionNV == VK_NULL_HANDLE;
2989  }
2990 
2991  private:
2992  VkOpticalFlowSessionNV m_opticalFlowSessionNV = {};
2993  };
2994 
2995  template <>
2997  {
2999  };
3000 
3001  template <>
3003  {
3005  };
3006 
3008  {
3009  public:
3010  using CType = VkDescriptorUpdateTemplate;
3011  using NativeType = VkDescriptorUpdateTemplate;
3012 
3016 
3017  public:
3020  VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
3021  : m_descriptorUpdateTemplate( descriptorUpdateTemplate )
3022  {
3023  }
3024 
3025 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3026  DescriptorUpdateTemplate & operator=( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
3027  {
3028  m_descriptorUpdateTemplate = descriptorUpdateTemplate;
3029  return *this;
3030  }
3031 #endif
3032 
3034  {
3035  m_descriptorUpdateTemplate = {};
3036  return *this;
3037  }
3038 
3039 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3040  auto operator<=>( DescriptorUpdateTemplate const & ) const = default;
3041 #else
3043  {
3044  return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate;
3045  }
3046 
3048  {
3049  return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate;
3050  }
3051 
3053  {
3054  return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate;
3055  }
3056 #endif
3057 
3058  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT
3059  {
3060  return m_descriptorUpdateTemplate;
3061  }
3062 
3063  explicit operator bool() const VULKAN_HPP_NOEXCEPT
3064  {
3065  return m_descriptorUpdateTemplate != VK_NULL_HANDLE;
3066  }
3067 
3069  {
3070  return m_descriptorUpdateTemplate == VK_NULL_HANDLE;
3071  }
3072 
3073  private:
3074  VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {};
3075  };
3076 
3077  template <>
3079  {
3081  };
3082 
3083  template <>
3085  {
3087  };
3088 
3089  template <>
3091  {
3093  };
3095 
3096  class Event
3097  {
3098  public:
3099  using CType = VkEvent;
3100  using NativeType = VkEvent;
3101 
3105 
3106  public:
3107  VULKAN_HPP_CONSTEXPR Event() = default;
3110 
3111 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3113  {
3114  m_event = event;
3115  return *this;
3116  }
3117 #endif
3118 
3120  {
3121  m_event = {};
3122  return *this;
3123  }
3124 
3125 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3126  auto operator<=>( Event const & ) const = default;
3127 #else
3128  bool operator==( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
3129  {
3130  return m_event == rhs.m_event;
3131  }
3132 
3133  bool operator!=( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
3134  {
3135  return m_event != rhs.m_event;
3136  }
3137 
3138  bool operator<( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
3139  {
3140  return m_event < rhs.m_event;
3141  }
3142 #endif
3143 
3145  {
3146  return m_event;
3147  }
3148 
3149  explicit operator bool() const VULKAN_HPP_NOEXCEPT
3150  {
3151  return m_event != VK_NULL_HANDLE;
3152  }
3153 
3155  {
3156  return m_event == VK_NULL_HANDLE;
3157  }
3158 
3159  private:
3160  VkEvent m_event = {};
3161  };
3162 
3163  template <>
3165  {
3167  };
3168 
3169  template <>
3171  {
3173  };
3174 
3175  template <>
3177  {
3179  };
3180 
3182  {
3183  public:
3184  using CType = VkAccelerationStructureKHR;
3185  using NativeType = VkAccelerationStructureKHR;
3186 
3190 
3191  public:
3194  VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
3195  : m_accelerationStructureKHR( accelerationStructureKHR )
3196  {
3197  }
3198 
3199 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3200  AccelerationStructureKHR & operator=( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
3201  {
3202  m_accelerationStructureKHR = accelerationStructureKHR;
3203  return *this;
3204  }
3205 #endif
3206 
3208  {
3209  m_accelerationStructureKHR = {};
3210  return *this;
3211  }
3212 
3213 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3214  auto operator<=>( AccelerationStructureKHR const & ) const = default;
3215 #else
3217  {
3218  return m_accelerationStructureKHR == rhs.m_accelerationStructureKHR;
3219  }
3220 
3222  {
3223  return m_accelerationStructureKHR != rhs.m_accelerationStructureKHR;
3224  }
3225 
3227  {
3228  return m_accelerationStructureKHR < rhs.m_accelerationStructureKHR;
3229  }
3230 #endif
3231 
3232  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT
3233  {
3234  return m_accelerationStructureKHR;
3235  }
3236 
3237  explicit operator bool() const VULKAN_HPP_NOEXCEPT
3238  {
3239  return m_accelerationStructureKHR != VK_NULL_HANDLE;
3240  }
3241 
3243  {
3244  return m_accelerationStructureKHR == VK_NULL_HANDLE;
3245  }
3246 
3247  private:
3248  VkAccelerationStructureKHR m_accelerationStructureKHR = {};
3249  };
3250 
3251  template <>
3253  {
3255  };
3256 
3257  template <>
3259  {
3261  };
3262 
3263  template <>
3265  {
3267  };
3268 
3270  {
3271  public:
3272  using CType = VkMicromapEXT;
3273  using NativeType = VkMicromapEXT;
3274 
3278 
3279  public:
3280  VULKAN_HPP_CONSTEXPR MicromapEXT() = default;
3282  VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT : m_micromapEXT( micromapEXT ) {}
3283 
3284 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3285  MicromapEXT & operator=( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT
3286  {
3287  m_micromapEXT = micromapEXT;
3288  return *this;
3289  }
3290 #endif
3291 
3293  {
3294  m_micromapEXT = {};
3295  return *this;
3296  }
3297 
3298 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3299  auto operator<=>( MicromapEXT const & ) const = default;
3300 #else
3301  bool operator==( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3302  {
3303  return m_micromapEXT == rhs.m_micromapEXT;
3304  }
3305 
3306  bool operator!=( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3307  {
3308  return m_micromapEXT != rhs.m_micromapEXT;
3309  }
3310 
3311  bool operator<( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3312  {
3313  return m_micromapEXT < rhs.m_micromapEXT;
3314  }
3315 #endif
3316 
3317  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkMicromapEXT() const VULKAN_HPP_NOEXCEPT
3318  {
3319  return m_micromapEXT;
3320  }
3321 
3322  explicit operator bool() const VULKAN_HPP_NOEXCEPT
3323  {
3324  return m_micromapEXT != VK_NULL_HANDLE;
3325  }
3326 
3328  {
3329  return m_micromapEXT == VK_NULL_HANDLE;
3330  }
3331 
3332  private:
3333  VkMicromapEXT m_micromapEXT = {};
3334  };
3335 
3336  template <>
3338  {
3340  };
3341 
3342  template <>
3344  {
3346  };
3347 
3349  {
3350  public:
3351  using CType = VkCommandBuffer;
3352  using NativeType = VkCommandBuffer;
3353 
3357 
3358  public:
3359  VULKAN_HPP_CONSTEXPR CommandBuffer() = default;
3361  CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( commandBuffer ) {}
3362 
3363  CommandBuffer & operator=( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
3364  {
3365  m_commandBuffer = commandBuffer;
3366  return *this;
3367  }
3368 
3370  {
3371  m_commandBuffer = {};
3372  return *this;
3373  }
3374 
3375 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3376  auto operator<=>( CommandBuffer const & ) const = default;
3377 #else
3379  {
3380  return m_commandBuffer == rhs.m_commandBuffer;
3381  }
3382 
3384  {
3385  return m_commandBuffer != rhs.m_commandBuffer;
3386  }
3387 
3388  bool operator<( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3389  {
3390  return m_commandBuffer < rhs.m_commandBuffer;
3391  }
3392 #endif
3393 
3394  //=== VK_VERSION_1_0 ===
3395 
3396  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3399 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3400  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3402  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
3403 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3404 
3405 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
3406  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3408 #else
3409  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3411 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3412 
3413 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
3414  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3417 #else
3418  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3420  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
3421 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3422 
3423  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3424  void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
3427 
3428  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3429  void setViewport( uint32_t firstViewport,
3430  uint32_t viewportCount,
3431  const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
3433 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3434  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3435  void setViewport( uint32_t firstViewport,
3438 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3439 
3440  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3441  void setScissor( uint32_t firstScissor,
3442  uint32_t scissorCount,
3443  const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
3445 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3446  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3447  void setScissor( uint32_t firstScissor,
3450 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3451 
3452  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3453  void setLineWidth( float lineWidth, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3454 
3455  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3456  void setDepthBias( float depthBiasConstantFactor,
3457  float depthBiasClamp,
3458  float depthBiasSlopeFactor,
3460 
3461  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3462  void setBlendConstants( const float blendConstants[4], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3463 
3464  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3465  void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3466 
3467  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3469  uint32_t compareMask,
3471 
3472  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3474  uint32_t writeMask,
3476 
3477  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3479  uint32_t reference,
3481 
3482  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3485  uint32_t firstSet,
3486  uint32_t descriptorSetCount,
3487  const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
3488  uint32_t dynamicOffsetCount,
3489  const uint32_t * pDynamicOffsets,
3491 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3492  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3495  uint32_t firstSet,
3497  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & dynamicOffsets,
3499 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3500 
3501  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3506 
3507  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3508  void bindVertexBuffers( uint32_t firstBinding,
3509  uint32_t bindingCount,
3510  const VULKAN_HPP_NAMESPACE::Buffer * pBuffers,
3511  const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
3513 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3514  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3515  void bindVertexBuffers( uint32_t firstBinding,
3519 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3520 
3521  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3522  void draw( uint32_t vertexCount,
3523  uint32_t instanceCount,
3524  uint32_t firstVertex,
3525  uint32_t firstInstance,
3527 
3528  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3529  void drawIndexed( uint32_t indexCount,
3530  uint32_t instanceCount,
3531  uint32_t firstIndex,
3532  int32_t vertexOffset,
3533  uint32_t firstInstance,
3535 
3536  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3539  uint32_t drawCount,
3540  uint32_t stride,
3542 
3543  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3546  uint32_t drawCount,
3547  uint32_t stride,
3549 
3550  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3551  void dispatch( uint32_t groupCountX,
3552  uint32_t groupCountY,
3553  uint32_t groupCountZ,
3555 
3556  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3560 
3561  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3562  void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
3563  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
3564  uint32_t regionCount,
3565  const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions,
3567 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3568  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3569  void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
3570  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
3573 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3574 
3575  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3576  void copyImage( VULKAN_HPP_NAMESPACE::Image srcImage,
3577  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
3578  VULKAN_HPP_NAMESPACE::Image dstImage,
3579  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
3580  uint32_t regionCount,
3581  const VULKAN_HPP_NAMESPACE::ImageCopy * pRegions,
3583 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3584  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3585  void copyImage( VULKAN_HPP_NAMESPACE::Image srcImage,
3586  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
3587  VULKAN_HPP_NAMESPACE::Image dstImage,
3588  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
3591 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3592 
3593  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3594  void blitImage( VULKAN_HPP_NAMESPACE::Image srcImage,
3595  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
3596  VULKAN_HPP_NAMESPACE::Image dstImage,
3597  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
3598  uint32_t regionCount,
3599  const VULKAN_HPP_NAMESPACE::ImageBlit * pRegions,
3602 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3603  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3604  void blitImage( VULKAN_HPP_NAMESPACE::Image srcImage,
3605  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
3606  VULKAN_HPP_NAMESPACE::Image dstImage,
3607  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
3611 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3612 
3613  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3615  VULKAN_HPP_NAMESPACE::Image dstImage,
3616  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
3617  uint32_t regionCount,
3618  const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
3620 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3621  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3623  VULKAN_HPP_NAMESPACE::Image dstImage,
3624  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
3627 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3628 
3629  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3631  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
3632  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
3633  uint32_t regionCount,
3634  const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
3636 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3637  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3639  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
3640  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
3643 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3644 
3645  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3649  const void * pData,
3651 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3652  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3657 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3658 
3659  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3660  void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
3663  uint32_t data,
3665 
3666  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3670  uint32_t rangeCount,
3673 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3674  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3680 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3681 
3682  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3685  const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue * pDepthStencil,
3686  uint32_t rangeCount,
3689 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3690  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3693  const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue & depthStencil,
3696 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3697 
3698  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3699  void clearAttachments( uint32_t attachmentCount,
3700  const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments,
3701  uint32_t rectCount,
3702  const VULKAN_HPP_NAMESPACE::ClearRect * pRects,
3704 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3705  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3709 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3710 
3711  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3713  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
3714  VULKAN_HPP_NAMESPACE::Image dstImage,
3715  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
3716  uint32_t regionCount,
3717  const VULKAN_HPP_NAMESPACE::ImageResolve * pRegions,
3719 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3720  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3722  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
3723  VULKAN_HPP_NAMESPACE::Image dstImage,
3724  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
3727 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3728 
3729  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3733 
3734  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3738 
3739  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3740  void waitEvents( uint32_t eventCount,
3741  const VULKAN_HPP_NAMESPACE::Event * pEvents,
3744  uint32_t memoryBarrierCount,
3745  const VULKAN_HPP_NAMESPACE::MemoryBarrier * pMemoryBarriers,
3746  uint32_t bufferMemoryBarrierCount,
3747  const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
3748  uint32_t imageMemoryBarrierCount,
3749  const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier * pImageMemoryBarriers,
3751 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3752  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3760 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3761 
3762  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3765  VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags,
3766  uint32_t memoryBarrierCount,
3767  const VULKAN_HPP_NAMESPACE::MemoryBarrier * pMemoryBarriers,
3768  uint32_t bufferMemoryBarrierCount,
3769  const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
3770  uint32_t imageMemoryBarrierCount,
3771  const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier * pImageMemoryBarriers,
3773 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3774  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3777  VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags,
3782 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3783 
3784  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3786  uint32_t query,
3789 
3790  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3791  void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
3792  uint32_t query,
3794 
3795  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3797  uint32_t firstQuery,
3798  uint32_t queryCount,
3800 
3801  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3804  uint32_t query,
3806 
3807  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3809  uint32_t firstQuery,
3810  uint32_t queryCount,
3811  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
3816 
3817  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3820  uint32_t offset,
3821  uint32_t size,
3822  const void * pValues,
3824 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3825  template <typename ValuesType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3828  uint32_t offset,
3831 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3832 
3833  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3834  void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
3837 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3838  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3839  void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
3842 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3843 
3844  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3846 
3847  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3849 
3850  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3851  void executeCommands( uint32_t commandBufferCount,
3852  const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
3854 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3855  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3858 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3859 
3860  //=== VK_VERSION_1_1 ===
3861 
3862  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3863  void setDeviceMask( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3864 
3865  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3866  void dispatchBase( uint32_t baseGroupX,
3867  uint32_t baseGroupY,
3868  uint32_t baseGroupZ,
3869  uint32_t groupCountX,
3870  uint32_t groupCountY,
3871  uint32_t groupCountZ,
3873 
3874  //=== VK_VERSION_1_2 ===
3875 
3876  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3879  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
3880  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
3881  uint32_t maxDrawCount,
3882  uint32_t stride,
3884 
3885  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3888  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
3889  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
3890  uint32_t maxDrawCount,
3891  uint32_t stride,
3893 
3894  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3895  void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
3896  const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
3898 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3899  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3900  void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
3901  const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
3903 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3904 
3905  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3906  void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
3907  const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
3909 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3910  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3911  void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
3912  const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,
3914 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3915 
3916  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3917  void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
3919 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3920  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3921  void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,
3923 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3924 
3925  //=== VK_VERSION_1_3 ===
3926 
3927  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3929  const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
3931 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3932  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3934  const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
3936 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3937 
3938  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3942 
3943  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3944  void waitEvents2( uint32_t eventCount,
3945  const VULKAN_HPP_NAMESPACE::Event * pEvents,
3946  const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos,
3948 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3949  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3953 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3954 
3955  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3956  void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
3958 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3959  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3960  void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
3962 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3963 
3964  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3967  uint32_t query,
3969 
3970  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3971  void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo,
3973 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3974  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3975  void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo,
3977 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3978 
3979  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3980  void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo,
3982 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3983  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3984  void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo,
3986 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3987 
3988  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3989  void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo,
3991 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3992  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3993  void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo,
3995 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3996 
3997  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3998  void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo,
4000 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4001  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4002  void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo,
4004 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4005 
4006  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4007  void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo,
4009 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4010  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4011  void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo,
4013 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4014 
4015  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4016  void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo,
4018 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4019  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4020  void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo,
4022 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4023 
4024  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4025  void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,
4027 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4028  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4029  void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,
4031 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4032 
4033  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4035 
4036  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4038 
4039  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4041 
4042  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4045 
4046  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4047  void setViewportWithCount( uint32_t viewportCount,
4048  const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
4050 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4051  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4054 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4055 
4056  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4057  void setScissorWithCount( uint32_t scissorCount,
4058  const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
4060 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4061  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4064 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4065 
4066  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4067  void bindVertexBuffers2( uint32_t firstBinding,
4068  uint32_t bindingCount,
4069  const VULKAN_HPP_NAMESPACE::Buffer * pBuffers,
4070  const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
4071  const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
4072  const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
4074 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4075  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4076  void bindVertexBuffers2(
4077  uint32_t firstBinding,
4081  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
4083 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4084 
4085  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4086  void setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,
4088 
4089  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4090  void setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,
4092 
4093  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4096 
4097  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4098  void setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
4100 
4101  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4102  void setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
4104 
4105  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4109  VULKAN_HPP_NAMESPACE::StencilOp depthFailOp,
4112 
4113  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4114  void setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,
4116 
4117  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4118  void setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,
4120 
4121  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4122  void setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,
4124 
4125  //=== VK_EXT_debug_marker ===
4126 
4127  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4130 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4131  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4134 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4135 
4136  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4138 
4139  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4142 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4143  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4146 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4147 
4148 #if defined( VK_ENABLE_BETA_EXTENSIONS )
4149  //=== VK_KHR_video_queue ===
4150 
4151  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4152  void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo,
4154 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4155  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4156  void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo,
4158 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4159 
4160  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4161  void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo,
4163 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4164  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4165  void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo,
4167 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4168 
4169  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4170  void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo,
4172 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4173  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4174  void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo,
4176 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4177 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
4178 
4179 #if defined( VK_ENABLE_BETA_EXTENSIONS )
4180  //=== VK_KHR_video_decode_queue ===
4181 
4182  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4183  void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pDecodeInfo,
4185 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4186  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4187  void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo,
4189 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4190 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
4191 
4192  //=== VK_EXT_transform_feedback ===
4193 
4194  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4195  void bindTransformFeedbackBuffersEXT( uint32_t firstBinding,
4196  uint32_t bindingCount,
4197  const VULKAN_HPP_NAMESPACE::Buffer * pBuffers,
4198  const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
4199  const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
4201 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4202  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4203  void bindTransformFeedbackBuffersEXT( uint32_t firstBinding,
4209 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4210 
4211  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4212  void beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
4213  uint32_t counterBufferCount,
4214  const VULKAN_HPP_NAMESPACE::Buffer * pCounterBuffers,
4215  const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
4217 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4218  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4219  void beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
4224 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4225 
4226  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4227  void endTransformFeedbackEXT( uint32_t firstCounterBuffer,
4228  uint32_t counterBufferCount,
4229  const VULKAN_HPP_NAMESPACE::Buffer * pCounterBuffers,
4230  const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
4232 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4233  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4234  void endTransformFeedbackEXT( uint32_t firstCounterBuffer,
4239 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4240 
4241  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4243  uint32_t query,
4245  uint32_t index,
4247 
4248  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4250  uint32_t query,
4251  uint32_t index,
4253 
4254  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4255  void drawIndirectByteCountEXT( uint32_t instanceCount,
4256  uint32_t firstInstance,
4257  VULKAN_HPP_NAMESPACE::Buffer counterBuffer,
4258  VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
4259  uint32_t counterOffset,
4260  uint32_t vertexStride,
4262 
4263  //=== VK_NVX_binary_import ===
4264 
4265  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4266  void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo,
4268 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4269  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4272 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4273 
4274  //=== VK_AMD_draw_indirect_count ===
4275 
4276  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4279  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
4280  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
4281  uint32_t maxDrawCount,
4282  uint32_t stride,
4284 
4285  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4288  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
4289  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
4290  uint32_t maxDrawCount,
4291  uint32_t stride,
4293 
4294  //=== VK_KHR_dynamic_rendering ===
4295 
4296  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4297  void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,
4299 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4300  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4301  void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,
4303 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4304 
4305  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4307 
4308  //=== VK_KHR_device_group ===
4309 
4310  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4311  void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4312 
4313  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4314  void dispatchBaseKHR( uint32_t baseGroupX,
4315  uint32_t baseGroupY,
4316  uint32_t baseGroupZ,
4317  uint32_t groupCountX,
4318  uint32_t groupCountY,
4319  uint32_t groupCountZ,
4321 
4322  //=== VK_KHR_push_descriptor ===
4323 
4324  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4327  uint32_t set,
4328  uint32_t descriptorWriteCount,
4329  const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
4331 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4332  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4335  uint32_t set,
4338 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4339 
4340  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4343  uint32_t set,
4344  const void * pData,
4346 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4347  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4350  uint32_t set,
4351  DataType const & data,
4353 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4354 
4355  //=== VK_EXT_conditional_rendering ===
4356 
4357  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4360 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4361  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4364 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4365 
4366  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4368 
4369  //=== VK_NV_clip_space_w_scaling ===
4370 
4371  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4372  void setViewportWScalingNV( uint32_t firstViewport,
4373  uint32_t viewportCount,
4374  const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings,
4376 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4377  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4378  void setViewportWScalingNV( uint32_t firstViewport,
4381 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4382 
4383  //=== VK_EXT_discard_rectangles ===
4384 
4385  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4386  void setDiscardRectangleEXT( uint32_t firstDiscardRectangle,
4387  uint32_t discardRectangleCount,
4388  const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles,
4390 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4391  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4392  void setDiscardRectangleEXT( uint32_t firstDiscardRectangle,
4395 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4396 
4397  //=== VK_KHR_create_renderpass2 ===
4398 
4399  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4400  void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
4401  const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
4403 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4404  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4405  void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
4406  const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
4408 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4409 
4410  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4411  void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
4412  const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
4414 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4415  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4416  void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
4417  const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,
4419 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4420 
4421  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4422  void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
4424 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4425  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4426  void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,
4428 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4429 
4430  //=== VK_EXT_debug_utils ===
4431 
4432  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4435 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4436  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4439 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4440 
4441  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4443 
4444  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4447 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4448  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4451 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4452 
4453  //=== VK_EXT_sample_locations ===
4454 
4455  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4456  void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo,
4458 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4459  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4460  void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo,
4462 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4463 
4464  //=== VK_KHR_acceleration_structure ===
4465 
4466  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4467  void buildAccelerationStructuresKHR( uint32_t infoCount,
4469  const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
4471 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4472  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4477 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4478 
4479  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4480  void buildAccelerationStructuresIndirectKHR( uint32_t infoCount,
4482  const VULKAN_HPP_NAMESPACE::DeviceAddress * pIndirectDeviceAddresses,
4483  const uint32_t * pIndirectStrides,
4484  const uint32_t * const * ppMaxPrimitiveCounts,
4486 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4487  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4491  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & indirectStrides,
4494 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4495 
4496  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4499 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4500  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4503 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4504 
4505  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4508 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4509  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4512 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4513 
4514  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4517 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4518  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4521 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4522 
4523  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4524  void writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount,
4525  const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
4528  uint32_t firstQuery,
4530 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4531  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4536  uint32_t firstQuery,
4538 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4539 
4540  //=== VK_NV_shading_rate_image ===
4541 
4542  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4546 
4547  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4548  void setViewportShadingRatePaletteNV( uint32_t firstViewport,
4549  uint32_t viewportCount,
4550  const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes,
4552 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4553  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4554  void setViewportShadingRatePaletteNV( uint32_t firstViewport,
4557 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4558 
4559  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4561  uint32_t customSampleOrderCount,
4562  const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders,
4564 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4565  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4569 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4570 
4571  //=== VK_NV_ray_tracing ===
4572 
4573  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4575  VULKAN_HPP_NAMESPACE::Buffer instanceData,
4576  VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset,
4581  VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset,
4583 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4584  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4586  VULKAN_HPP_NAMESPACE::Buffer instanceData,
4587  VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset,
4592  VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset,
4594 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4595 
4596  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4601 
4602  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4603  void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer,
4604  VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
4605  VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer,
4606  VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
4607  VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
4608  VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer,
4609  VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
4610  VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
4611  VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer,
4612  VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
4613  VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
4614  uint32_t width,
4615  uint32_t height,
4616  uint32_t depth,
4618 
4619  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4620  void writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount,
4621  const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructures,
4624  uint32_t firstQuery,
4626 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4627  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4632  uint32_t firstQuery,
4634 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4635 
4636  //=== VK_KHR_draw_indirect_count ===
4637 
4638  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4641  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
4642  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
4643  uint32_t maxDrawCount,
4644  uint32_t stride,
4646 
4647  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4650  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
4651  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
4652  uint32_t maxDrawCount,
4653  uint32_t stride,
4655 
4656  //=== VK_AMD_buffer_marker ===
4657 
4658  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4660  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
4662  uint32_t marker,
4664 
4665  //=== VK_NV_mesh_shader ===
4666 
4667  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4668  void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4669 
4670  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4673  uint32_t drawCount,
4674  uint32_t stride,
4676 
4677  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4680  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
4681  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
4682  uint32_t maxDrawCount,
4683  uint32_t stride,
4685 
4686  //=== VK_NV_scissor_exclusive ===
4687 
4688  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4689  void setExclusiveScissorNV( uint32_t firstExclusiveScissor,
4690  uint32_t exclusiveScissorCount,
4691  const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors,
4693 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4694  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4695  void setExclusiveScissorNV( uint32_t firstExclusiveScissor,
4698 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4699 
4700  //=== VK_NV_device_diagnostic_checkpoints ===
4701 
4702  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4703  void setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4704 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4705  template <typename CheckpointMarkerType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4706  void setCheckpointNV( CheckpointMarkerType const & checkpointMarker,
4708 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4709 
4710  //=== VK_INTEL_performance_query ===
4711 
4712  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4715 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4716  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4719  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4720 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4721 
4722  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4725 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4726  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4729  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4730 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4731 
4732  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4735 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4736  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4739  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4740 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4741 
4742  //=== VK_KHR_fragment_shading_rate ===
4743 
4744  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4745  void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D * pFragmentSize,
4748 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4749  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4750  void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D & fragmentSize,
4753 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4754 
4755  //=== VK_EXT_line_rasterization ===
4756 
4757  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4758  void setLineStippleEXT( uint32_t lineStippleFactor,
4759  uint16_t lineStipplePattern,
4761 
4762  //=== VK_EXT_extended_dynamic_state ===
4763 
4764  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4766 
4767  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4769 
4770  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4773 
4774  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4775  void setViewportWithCountEXT( uint32_t viewportCount,
4776  const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
4778 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4779  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4782 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4783 
4784  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4785  void setScissorWithCountEXT( uint32_t scissorCount,
4786  const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
4788 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4789  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4792 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4793 
4794  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4795  void bindVertexBuffers2EXT( uint32_t firstBinding,
4796  uint32_t bindingCount,
4797  const VULKAN_HPP_NAMESPACE::Buffer * pBuffers,
4798  const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
4799  const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
4800  const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
4802 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4803  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4804  void bindVertexBuffers2EXT(
4805  uint32_t firstBinding,
4809  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
4811 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4812 
4813  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4816 
4817  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4820 
4821  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4824 
4825  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4826  void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
4828 
4829  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4830  void setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
4832 
4833  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4837  VULKAN_HPP_NAMESPACE::StencilOp depthFailOp,
4840 
4841  //=== VK_NV_device_generated_commands ===
4842 
4843  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4846 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4847  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4850 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4851 
4852  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4854  const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
4856 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4857  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4859  const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo,
4861 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4862 
4863  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4866  uint32_t groupIndex,
4868 
4869 #if defined( VK_ENABLE_BETA_EXTENSIONS )
4870  //=== VK_KHR_video_encode_queue ===
4871 
4872  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4873  void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo,
4875 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4876  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4877  void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo,
4879 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4880 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
4881 
4882  //=== VK_KHR_synchronization2 ===
4883 
4884  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4886  const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
4888 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4889  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4891  const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
4893 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4894 
4895  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4899 
4900  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4901  void waitEvents2KHR( uint32_t eventCount,
4902  const VULKAN_HPP_NAMESPACE::Event * pEvents,
4903  const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos,
4905 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4906  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4910 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4911 
4912  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4913  void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
4915 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4916  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4917  void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
4919 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4920 
4921  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4924  uint32_t query,
4926 
4927  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4929  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
4931  uint32_t marker,
4933 
4934  //=== VK_EXT_descriptor_buffer ===
4935 
4936  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4937  void bindDescriptorBuffersEXT( uint32_t bufferCount,
4940 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4941  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4944 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4945 
4946  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4949  uint32_t firstSet,
4950  uint32_t setCount,
4951  const uint32_t * pBufferIndices,
4952  const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
4954 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4955  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4958  uint32_t firstSet,
4962 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4963 
4964  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4967  uint32_t set,
4969 
4970  //=== VK_NV_fragment_shading_rate_enums ===
4971 
4972  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4976 
4977  //=== VK_EXT_mesh_shader ===
4978 
4979  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4980  void drawMeshTasksEXT( uint32_t groupCountX,
4981  uint32_t groupCountY,
4982  uint32_t groupCountZ,
4984 
4985  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4988  uint32_t drawCount,
4989  uint32_t stride,
4991 
4992  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4995  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
4996  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
4997  uint32_t maxDrawCount,
4998  uint32_t stride,
5000 
5001  //=== VK_KHR_copy_commands2 ===
5002 
5003  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5004  void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo,
5006 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5007  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5008  void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo,
5010 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5011 
5012  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5013  void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo,
5015 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5016  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5017  void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo,
5019 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5020 
5021  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5022  void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo,
5024 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5025  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5026  void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo,
5028 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5029 
5030  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5031  void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo,
5033 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5034  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5035  void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo,
5037 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5038 
5039  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5040  void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo,
5042 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5043  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5044  void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo,
5046 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5047 
5048  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5049  void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo,
5051 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5052  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5053  void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo,
5055 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5056 
5057  //=== VK_KHR_ray_tracing_pipeline ===
5058 
5059  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5060  void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
5061  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
5062  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
5063  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
5064  uint32_t width,
5065  uint32_t height,
5066  uint32_t depth,
5068 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5069  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5070  void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
5071  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
5072  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
5073  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
5074  uint32_t width,
5075  uint32_t height,
5076  uint32_t depth,
5078 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5079 
5080  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5081  void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
5082  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
5083  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
5084  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
5085  VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress,
5087 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5088  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5089  void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
5090  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
5091  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
5092  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
5093  VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress,
5095 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5096 
5097  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5098  void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5099 
5100  //=== VK_EXT_vertex_input_dynamic_state ===
5101 
5102  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5103  void setVertexInputEXT( uint32_t vertexBindingDescriptionCount,
5104  const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT * pVertexBindingDescriptions,
5105  uint32_t vertexAttributeDescriptionCount,
5106  const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions,
5108 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5109  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5110  void
5114 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5115 
5116  //=== VK_HUAWEI_subpass_shading ===
5117 
5118  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5120 
5121  //=== VK_HUAWEI_invocation_mask ===
5122 
5123  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5127 
5128  //=== VK_EXT_extended_dynamic_state2 ===
5129 
5130  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5131  void setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5132 
5133  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5134  void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,
5136 
5137  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5140 
5141  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5143 
5144  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5145  void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,
5147 
5148  //=== VK_EXT_color_write_enable ===
5149 
5150  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5151  void setColorWriteEnableEXT( uint32_t attachmentCount,
5152  const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables,
5154 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5155  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5158 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5159 
5160  //=== VK_KHR_ray_tracing_maintenance1 ===
5161 
5162  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5163  void traceRaysIndirect2KHR( VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress,
5165 
5166  //=== VK_EXT_multi_draw ===
5167 
5168  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5169  void drawMultiEXT( uint32_t drawCount,
5170  const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT * pVertexInfo,
5171  uint32_t instanceCount,
5172  uint32_t firstInstance,
5173  uint32_t stride,
5175 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5176  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5178  uint32_t instanceCount,
5179  uint32_t firstInstance,
5181 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5182 
5183  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5184  void drawMultiIndexedEXT( uint32_t drawCount,
5186  uint32_t instanceCount,
5187  uint32_t firstInstance,
5188  uint32_t stride,
5189  const int32_t * pVertexOffset,
5191 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5192  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5194  uint32_t instanceCount,
5195  uint32_t firstInstance,
5198 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5199 
5200  //=== VK_EXT_opacity_micromap ===
5201 
5202  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5203  void buildMicromapsEXT( uint32_t infoCount,
5206 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5207  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5210 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5211 
5212  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5215 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5216  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5219 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5220 
5221  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5224 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5225  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5228 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5229 
5230  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5233 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5234  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5237 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5238 
5239  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5240  void writeMicromapsPropertiesEXT( uint32_t micromapCount,
5241  const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps,
5244  uint32_t firstQuery,
5246 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5247  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5251  uint32_t firstQuery,
5253 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5254 
5255  //=== VK_NV_copy_memory_indirect ===
5256 
5257  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5259  uint32_t copyCount,
5260  uint32_t stride,
5262 
5263  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5265  uint32_t copyCount,
5266  uint32_t stride,
5267  VULKAN_HPP_NAMESPACE::Image dstImage,
5268  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
5269  const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers * pImageSubresources,
5271 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5272  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5274  uint32_t stride,
5275  VULKAN_HPP_NAMESPACE::Image dstImage,
5276  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
5279 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5280 
5281  //=== VK_NV_memory_decompression ===
5282 
5283  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5284  void decompressMemoryNV( uint32_t decompressRegionCount,
5285  const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV * pDecompressMemoryRegions,
5287 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5288  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5291 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5292 
5293  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5295  VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress,
5296  uint32_t stride,
5298 
5299  //=== VK_EXT_extended_dynamic_state3 ===
5300 
5301  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5304 
5305  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5308 
5309  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5312 
5313  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5316 
5317  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5319  const VULKAN_HPP_NAMESPACE::SampleMask * pSampleMask,
5321 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5322  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5326 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5327 
5328  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5329  void setAlphaToCoverageEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable,
5331 
5332  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5335 
5336  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5339 
5340  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5341  void setColorBlendEnableEXT( uint32_t firstAttachment,
5342  uint32_t attachmentCount,
5343  const VULKAN_HPP_NAMESPACE::Bool32 * pColorBlendEnables,
5345 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5346  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5347  void setColorBlendEnableEXT( uint32_t firstAttachment,
5350 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5351 
5352  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5353  void setColorBlendEquationEXT( uint32_t firstAttachment,
5354  uint32_t attachmentCount,
5355  const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT * pColorBlendEquations,
5357 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5358  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5359  void setColorBlendEquationEXT( uint32_t firstAttachment,
5362 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5363 
5364  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5365  void setColorWriteMaskEXT( uint32_t firstAttachment,
5366  uint32_t attachmentCount,
5367  const VULKAN_HPP_NAMESPACE::ColorComponentFlags * pColorWriteMasks,
5369 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5370  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5371  void setColorWriteMaskEXT( uint32_t firstAttachment,
5374 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5375 
5376  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5377  void setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5378 
5379  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5382 
5383  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5384  void setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize,
5386 
5387  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5390 
5391  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5392  void setSampleLocationsEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable,
5394 
5395  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5396  void setColorBlendAdvancedEXT( uint32_t firstAttachment,
5397  uint32_t attachmentCount,
5398  const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT * pColorBlendAdvanced,
5400 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5401  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5402  void setColorBlendAdvancedEXT( uint32_t firstAttachment,
5405 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5406 
5407  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5410 
5411  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5414 
5415  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5416  void setLineStippleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable,
5418 
5419  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5422 
5423  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5424  void setViewportWScalingEnableNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable,
5426 
5427  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5428  void setViewportSwizzleNV( uint32_t firstViewport,
5429  uint32_t viewportCount,
5430  const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV * pViewportSwizzles,
5432 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5433  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5434  void setViewportSwizzleNV( uint32_t firstViewport,
5437 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5438 
5439  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5440  void setCoverageToColorEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable,
5442 
5443  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5444  void setCoverageToColorLocationNV( uint32_t coverageToColorLocation,
5446 
5447  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5450 
5451  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5452  void setCoverageModulationTableEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable,
5454 
5455  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5456  void setCoverageModulationTableNV( uint32_t coverageModulationTableCount,
5457  const float * pCoverageModulationTable,
5459 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5460  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5463 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5464 
5465  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5466  void setShadingRateImageEnableNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable,
5468 
5469  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5470  void setRepresentativeFragmentTestEnableNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable,
5472 
5473  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5476 
5477  //=== VK_NV_optical_flow ===
5478 
5479  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5483 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5484  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5488 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5489 
5490  operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
5491  {
5492  return m_commandBuffer;
5493  }
5494 
5495  explicit operator bool() const VULKAN_HPP_NOEXCEPT
5496  {
5497  return m_commandBuffer != VK_NULL_HANDLE;
5498  }
5499 
5501  {
5502  return m_commandBuffer == VK_NULL_HANDLE;
5503  }
5504 
5505  private:
5506  VkCommandBuffer m_commandBuffer = {};
5507  };
5508 
5509  template <>
5511  {
5513  };
5514 
5515  template <>
5517  {
5519  };
5520 
5521  template <>
5523  {
5525  };
5526 
5528  {
5529  public:
5530  using CType = VkDeviceMemory;
5531  using NativeType = VkDeviceMemory;
5532 
5536 
5537  public:
5538  VULKAN_HPP_CONSTEXPR DeviceMemory() = default;
5540  VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( deviceMemory ) {}
5541 
5542 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
5543  DeviceMemory & operator=( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
5544  {
5545  m_deviceMemory = deviceMemory;
5546  return *this;
5547  }
5548 #endif
5549 
5551  {
5552  m_deviceMemory = {};
5553  return *this;
5554  }
5555 
5556 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5557  auto operator<=>( DeviceMemory const & ) const = default;
5558 #else
5559  bool operator==( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
5560  {
5561  return m_deviceMemory == rhs.m_deviceMemory;
5562  }
5563 
5564  bool operator!=( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
5565  {
5566  return m_deviceMemory != rhs.m_deviceMemory;
5567  }
5568 
5569  bool operator<( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
5570  {
5571  return m_deviceMemory < rhs.m_deviceMemory;
5572  }
5573 #endif
5574 
5575  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT
5576  {
5577  return m_deviceMemory;
5578  }
5579 
5580  explicit operator bool() const VULKAN_HPP_NOEXCEPT
5581  {
5582  return m_deviceMemory != VK_NULL_HANDLE;
5583  }
5584 
5586  {
5587  return m_deviceMemory == VK_NULL_HANDLE;
5588  }
5589 
5590  private:
5591  VkDeviceMemory m_deviceMemory = {};
5592  };
5593 
5594  template <>
5596  {
5598  };
5599 
5600  template <>
5602  {
5604  };
5605 
5606  template <>
5608  {
5610  };
5611 
5612 #if defined( VK_ENABLE_BETA_EXTENSIONS )
5613  class VideoSessionKHR
5614  {
5615  public:
5616  using CType = VkVideoSessionKHR;
5617  using NativeType = VkVideoSessionKHR;
5618 
5619  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR;
5622 
5623  public:
5624  VULKAN_HPP_CONSTEXPR VideoSessionKHR() = default;
5625  VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
5626  VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( videoSessionKHR ) {}
5627 
5628 # if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
5629  VideoSessionKHR & operator=( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
5630  {
5631  m_videoSessionKHR = videoSessionKHR;
5632  return *this;
5633  }
5634 # endif
5635 
5636  VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5637  {
5638  m_videoSessionKHR = {};
5639  return *this;
5640  }
5641 
5642 # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5643  auto operator<=>( VideoSessionKHR const & ) const = default;
5644 # else
5645  bool operator==( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5646  {
5647  return m_videoSessionKHR == rhs.m_videoSessionKHR;
5648  }
5649 
5650  bool operator!=( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5651  {
5652  return m_videoSessionKHR != rhs.m_videoSessionKHR;
5653  }
5654 
5655  bool operator<( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5656  {
5657  return m_videoSessionKHR < rhs.m_videoSessionKHR;
5658  }
5659 # endif
5660 
5661  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionKHR() const VULKAN_HPP_NOEXCEPT
5662  {
5663  return m_videoSessionKHR;
5664  }
5665 
5666  explicit operator bool() const VULKAN_HPP_NOEXCEPT
5667  {
5668  return m_videoSessionKHR != VK_NULL_HANDLE;
5669  }
5670 
5671  bool operator!() const VULKAN_HPP_NOEXCEPT
5672  {
5673  return m_videoSessionKHR == VK_NULL_HANDLE;
5674  }
5675 
5676  private:
5677  VkVideoSessionKHR m_videoSessionKHR = {};
5678  };
5679 
5680  template <>
5681  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR>
5682  {
5683  using Type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;
5684  };
5685 
5686  template <>
5687  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
5688  {
5689  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5690  };
5691 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
5692 
5694  {
5695  public:
5696  using CType = VkDeferredOperationKHR;
5697  using NativeType = VkDeferredOperationKHR;
5698 
5702 
5703  public:
5706  VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
5707  : m_deferredOperationKHR( deferredOperationKHR )
5708  {
5709  }
5710 
5711 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
5712  DeferredOperationKHR & operator=( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
5713  {
5714  m_deferredOperationKHR = deferredOperationKHR;
5715  return *this;
5716  }
5717 #endif
5718 
5720  {
5721  m_deferredOperationKHR = {};
5722  return *this;
5723  }
5724 
5725 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5726  auto operator<=>( DeferredOperationKHR const & ) const = default;
5727 #else
5729  {
5730  return m_deferredOperationKHR == rhs.m_deferredOperationKHR;
5731  }
5732 
5734  {
5735  return m_deferredOperationKHR != rhs.m_deferredOperationKHR;
5736  }
5737 
5739  {
5740  return m_deferredOperationKHR < rhs.m_deferredOperationKHR;
5741  }
5742 #endif
5743 
5744  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeferredOperationKHR() const VULKAN_HPP_NOEXCEPT
5745  {
5746  return m_deferredOperationKHR;
5747  }
5748 
5749  explicit operator bool() const VULKAN_HPP_NOEXCEPT
5750  {
5751  return m_deferredOperationKHR != VK_NULL_HANDLE;
5752  }
5753 
5755  {
5756  return m_deferredOperationKHR == VK_NULL_HANDLE;
5757  }
5758 
5759  private:
5760  VkDeferredOperationKHR m_deferredOperationKHR = {};
5761  };
5762 
5763  template <>
5765  {
5767  };
5768 
5769  template <>
5771  {
5773  };
5774 
5775 #if defined( VK_USE_PLATFORM_FUCHSIA )
5776  class BufferCollectionFUCHSIA
5777  {
5778  public:
5779  using CType = VkBufferCollectionFUCHSIA;
5780  using NativeType = VkBufferCollectionFUCHSIA;
5781 
5782  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA;
5784  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA;
5785 
5786  public:
5787  VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA() = default;
5788  VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
5789  VULKAN_HPP_TYPESAFE_EXPLICIT BufferCollectionFUCHSIA( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
5790  : m_bufferCollectionFUCHSIA( bufferCollectionFUCHSIA )
5791  {
5792  }
5793 
5794 # if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
5795  BufferCollectionFUCHSIA & operator=( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
5796  {
5797  m_bufferCollectionFUCHSIA = bufferCollectionFUCHSIA;
5798  return *this;
5799  }
5800 # endif
5801 
5802  BufferCollectionFUCHSIA & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5803  {
5804  m_bufferCollectionFUCHSIA = {};
5805  return *this;
5806  }
5807 
5808 # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5809  auto operator<=>( BufferCollectionFUCHSIA const & ) const = default;
5810 # else
5811  bool operator==( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
5812  {
5813  return m_bufferCollectionFUCHSIA == rhs.m_bufferCollectionFUCHSIA;
5814  }
5815 
5816  bool operator!=( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
5817  {
5818  return m_bufferCollectionFUCHSIA != rhs.m_bufferCollectionFUCHSIA;
5819  }
5820 
5821  bool operator<( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
5822  {
5823  return m_bufferCollectionFUCHSIA < rhs.m_bufferCollectionFUCHSIA;
5824  }
5825 # endif
5826 
5827  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT
5828  {
5829  return m_bufferCollectionFUCHSIA;
5830  }
5831 
5832  explicit operator bool() const VULKAN_HPP_NOEXCEPT
5833  {
5834  return m_bufferCollectionFUCHSIA != VK_NULL_HANDLE;
5835  }
5836 
5837  bool operator!() const VULKAN_HPP_NOEXCEPT
5838  {
5839  return m_bufferCollectionFUCHSIA == VK_NULL_HANDLE;
5840  }
5841 
5842  private:
5843  VkBufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {};
5844  };
5845 
5846  template <>
5847  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA>
5848  {
5849  using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
5850  };
5851 
5852  template <>
5853  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA>
5854  {
5855  using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
5856  };
5857 
5858  template <>
5859  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>
5860  {
5861  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5862  };
5863 #endif /*VK_USE_PLATFORM_FUCHSIA*/
5864 
5866  {
5867  public:
5868  using CType = VkBufferView;
5869  using NativeType = VkBufferView;
5870 
5874 
5875  public:
5876  VULKAN_HPP_CONSTEXPR BufferView() = default;
5878  VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT : m_bufferView( bufferView ) {}
5879 
5880 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
5881  BufferView & operator=( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT
5882  {
5883  m_bufferView = bufferView;
5884  return *this;
5885  }
5886 #endif
5887 
5889  {
5890  m_bufferView = {};
5891  return *this;
5892  }
5893 
5894 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5895  auto operator<=>( BufferView const & ) const = default;
5896 #else
5897  bool operator==( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
5898  {
5899  return m_bufferView == rhs.m_bufferView;
5900  }
5901 
5902  bool operator!=( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
5903  {
5904  return m_bufferView != rhs.m_bufferView;
5905  }
5906 
5907  bool operator<( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
5908  {
5909  return m_bufferView < rhs.m_bufferView;
5910  }
5911 #endif
5912 
5914  {
5915  return m_bufferView;
5916  }
5917 
5918  explicit operator bool() const VULKAN_HPP_NOEXCEPT
5919  {
5920  return m_bufferView != VK_NULL_HANDLE;
5921  }
5922 
5924  {
5925  return m_bufferView == VK_NULL_HANDLE;
5926  }
5927 
5928  private:
5929  VkBufferView m_bufferView = {};
5930  };
5931 
5932  template <>
5934  {
5936  };
5937 
5938  template <>
5940  {
5942  };
5943 
5944  template <>
5946  {
5948  };
5949 
5951  {
5952  public:
5953  using CType = VkCommandPool;
5954  using NativeType = VkCommandPool;
5955 
5959 
5960  public:
5961  VULKAN_HPP_CONSTEXPR CommandPool() = default;
5963  VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT : m_commandPool( commandPool ) {}
5964 
5965 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
5966  CommandPool & operator=( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
5967  {
5968  m_commandPool = commandPool;
5969  return *this;
5970  }
5971 #endif
5972 
5974  {
5975  m_commandPool = {};
5976  return *this;
5977  }
5978 
5979 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5980  auto operator<=>( CommandPool const & ) const = default;
5981 #else
5982  bool operator==( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5983  {
5984  return m_commandPool == rhs.m_commandPool;
5985  }
5986 
5987  bool operator!=( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5988  {
5989  return m_commandPool != rhs.m_commandPool;
5990  }
5991 
5992  bool operator<( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5993  {
5994  return m_commandPool < rhs.m_commandPool;
5995  }
5996 #endif
5997 
5998  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT
5999  {
6000  return m_commandPool;
6001  }
6002 
6003  explicit operator bool() const VULKAN_HPP_NOEXCEPT
6004  {
6005  return m_commandPool != VK_NULL_HANDLE;
6006  }
6007 
6009  {
6010  return m_commandPool == VK_NULL_HANDLE;
6011  }
6012 
6013  private:
6014  VkCommandPool m_commandPool = {};
6015  };
6016 
6017  template <>
6019  {
6021  };
6022 
6023  template <>
6025  {
6027  };
6028 
6029  template <>
6031  {
6033  };
6034 
6036  {
6037  public:
6038  using CType = VkPipelineCache;
6039  using NativeType = VkPipelineCache;
6040 
6044 
6045  public:
6046  VULKAN_HPP_CONSTEXPR PipelineCache() = default;
6048  VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( pipelineCache ) {}
6049 
6050 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6051  PipelineCache & operator=( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
6052  {
6053  m_pipelineCache = pipelineCache;
6054  return *this;
6055  }
6056 #endif
6057 
6059  {
6060  m_pipelineCache = {};
6061  return *this;
6062  }
6063 
6064 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6065  auto operator<=>( PipelineCache const & ) const = default;
6066 #else
6068  {
6069  return m_pipelineCache == rhs.m_pipelineCache;
6070  }
6071 
6073  {
6074  return m_pipelineCache != rhs.m_pipelineCache;
6075  }
6076 
6077  bool operator<( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
6078  {
6079  return m_pipelineCache < rhs.m_pipelineCache;
6080  }
6081 #endif
6082 
6083  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT
6084  {
6085  return m_pipelineCache;
6086  }
6087 
6088  explicit operator bool() const VULKAN_HPP_NOEXCEPT
6089  {
6090  return m_pipelineCache != VK_NULL_HANDLE;
6091  }
6092 
6094  {
6095  return m_pipelineCache == VK_NULL_HANDLE;
6096  }
6097 
6098  private:
6099  VkPipelineCache m_pipelineCache = {};
6100  };
6101 
6102  template <>
6104  {
6106  };
6107 
6108  template <>
6110  {
6112  };
6113 
6114  template <>
6116  {
6118  };
6119 
6121  {
6122  public:
6123  using CType = VkCuFunctionNVX;
6124  using NativeType = VkCuFunctionNVX;
6125 
6129 
6130  public:
6131  VULKAN_HPP_CONSTEXPR CuFunctionNVX() = default;
6133  VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT : m_cuFunctionNVX( cuFunctionNVX ) {}
6134 
6135 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6136  CuFunctionNVX & operator=( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT
6137  {
6138  m_cuFunctionNVX = cuFunctionNVX;
6139  return *this;
6140  }
6141 #endif
6142 
6144  {
6145  m_cuFunctionNVX = {};
6146  return *this;
6147  }
6148 
6149 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6150  auto operator<=>( CuFunctionNVX const & ) const = default;
6151 #else
6153  {
6154  return m_cuFunctionNVX == rhs.m_cuFunctionNVX;
6155  }
6156 
6158  {
6159  return m_cuFunctionNVX != rhs.m_cuFunctionNVX;
6160  }
6161 
6162  bool operator<( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
6163  {
6164  return m_cuFunctionNVX < rhs.m_cuFunctionNVX;
6165  }
6166 #endif
6167 
6168  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuFunctionNVX() const VULKAN_HPP_NOEXCEPT
6169  {
6170  return m_cuFunctionNVX;
6171  }
6172 
6173  explicit operator bool() const VULKAN_HPP_NOEXCEPT
6174  {
6175  return m_cuFunctionNVX != VK_NULL_HANDLE;
6176  }
6177 
6179  {
6180  return m_cuFunctionNVX == VK_NULL_HANDLE;
6181  }
6182 
6183  private:
6184  VkCuFunctionNVX m_cuFunctionNVX = {};
6185  };
6186 
6187  template <>
6189  {
6191  };
6192 
6193  template <>
6195  {
6197  };
6198 
6199  template <>
6201  {
6203  };
6204 
6206  {
6207  public:
6208  using CType = VkCuModuleNVX;
6209  using NativeType = VkCuModuleNVX;
6210 
6214 
6215  public:
6216  VULKAN_HPP_CONSTEXPR CuModuleNVX() = default;
6218  VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT : m_cuModuleNVX( cuModuleNVX ) {}
6219 
6220 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6221  CuModuleNVX & operator=( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT
6222  {
6223  m_cuModuleNVX = cuModuleNVX;
6224  return *this;
6225  }
6226 #endif
6227 
6229  {
6230  m_cuModuleNVX = {};
6231  return *this;
6232  }
6233 
6234 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6235  auto operator<=>( CuModuleNVX const & ) const = default;
6236 #else
6237  bool operator==( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
6238  {
6239  return m_cuModuleNVX == rhs.m_cuModuleNVX;
6240  }
6241 
6242  bool operator!=( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
6243  {
6244  return m_cuModuleNVX != rhs.m_cuModuleNVX;
6245  }
6246 
6247  bool operator<( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
6248  {
6249  return m_cuModuleNVX < rhs.m_cuModuleNVX;
6250  }
6251 #endif
6252 
6253  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuModuleNVX() const VULKAN_HPP_NOEXCEPT
6254  {
6255  return m_cuModuleNVX;
6256  }
6257 
6258  explicit operator bool() const VULKAN_HPP_NOEXCEPT
6259  {
6260  return m_cuModuleNVX != VK_NULL_HANDLE;
6261  }
6262 
6264  {
6265  return m_cuModuleNVX == VK_NULL_HANDLE;
6266  }
6267 
6268  private:
6269  VkCuModuleNVX m_cuModuleNVX = {};
6270  };
6271 
6272  template <>
6274  {
6276  };
6277 
6278  template <>
6280  {
6282  };
6283 
6284  template <>
6286  {
6288  };
6289 
6291  {
6292  public:
6293  using CType = VkDescriptorPool;
6294  using NativeType = VkDescriptorPool;
6295 
6299 
6300  public:
6303  VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( descriptorPool ) {}
6304 
6305 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6306  DescriptorPool & operator=( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
6307  {
6308  m_descriptorPool = descriptorPool;
6309  return *this;
6310  }
6311 #endif
6312 
6314  {
6315  m_descriptorPool = {};
6316  return *this;
6317  }
6318 
6319 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6320  auto operator<=>( DescriptorPool const & ) const = default;
6321 #else
6323  {
6324  return m_descriptorPool == rhs.m_descriptorPool;
6325  }
6326 
6328  {
6329  return m_descriptorPool != rhs.m_descriptorPool;
6330  }
6331 
6333  {
6334  return m_descriptorPool < rhs.m_descriptorPool;
6335  }
6336 #endif
6337 
6338  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT
6339  {
6340  return m_descriptorPool;
6341  }
6342 
6343  explicit operator bool() const VULKAN_HPP_NOEXCEPT
6344  {
6345  return m_descriptorPool != VK_NULL_HANDLE;
6346  }
6347 
6349  {
6350  return m_descriptorPool == VK_NULL_HANDLE;
6351  }
6352 
6353  private:
6354  VkDescriptorPool m_descriptorPool = {};
6355  };
6356 
6357  template <>
6359  {
6361  };
6362 
6363  template <>
6365  {
6367  };
6368 
6369  template <>
6371  {
6373  };
6374 
6376  {
6377  public:
6378  using CType = VkDescriptorSetLayout;
6379  using NativeType = VkDescriptorSetLayout;
6380 
6384 
6385  public:
6388  VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
6389  : m_descriptorSetLayout( descriptorSetLayout )
6390  {
6391  }
6392 
6393 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6394  DescriptorSetLayout & operator=( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
6395  {
6396  m_descriptorSetLayout = descriptorSetLayout;
6397  return *this;
6398  }
6399 #endif
6400 
6402  {
6403  m_descriptorSetLayout = {};
6404  return *this;
6405  }
6406 
6407 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6408  auto operator<=>( DescriptorSetLayout const & ) const = default;
6409 #else
6411  {
6412  return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
6413  }
6414 
6416  {
6417  return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
6418  }
6419 
6421  {
6422  return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
6423  }
6424 #endif
6425 
6426  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT
6427  {
6428  return m_descriptorSetLayout;
6429  }
6430 
6431  explicit operator bool() const VULKAN_HPP_NOEXCEPT
6432  {
6433  return m_descriptorSetLayout != VK_NULL_HANDLE;
6434  }
6435 
6437  {
6438  return m_descriptorSetLayout == VK_NULL_HANDLE;
6439  }
6440 
6441  private:
6442  VkDescriptorSetLayout m_descriptorSetLayout = {};
6443  };
6444 
6445  template <>
6447  {
6449  };
6450 
6451  template <>
6453  {
6455  };
6456 
6457  template <>
6459  {
6461  };
6462 
6464  {
6465  public:
6466  using CType = VkFramebuffer;
6467  using NativeType = VkFramebuffer;
6468 
6472 
6473  public:
6474  VULKAN_HPP_CONSTEXPR Framebuffer() = default;
6477 
6478 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6480  {
6481  m_framebuffer = framebuffer;
6482  return *this;
6483  }
6484 #endif
6485 
6487  {
6488  m_framebuffer = {};
6489  return *this;
6490  }
6491 
6492 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6493  auto operator<=>( Framebuffer const & ) const = default;
6494 #else
6495  bool operator==( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
6496  {
6497  return m_framebuffer == rhs.m_framebuffer;
6498  }
6499 
6500  bool operator!=( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
6501  {
6502  return m_framebuffer != rhs.m_framebuffer;
6503  }
6504 
6505  bool operator<( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
6506  {
6507  return m_framebuffer < rhs.m_framebuffer;
6508  }
6509 #endif
6510 
6511  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT
6512  {
6513  return m_framebuffer;
6514  }
6515 
6516  explicit operator bool() const VULKAN_HPP_NOEXCEPT
6517  {
6518  return m_framebuffer != VK_NULL_HANDLE;
6519  }
6520 
6522  {
6523  return m_framebuffer == VK_NULL_HANDLE;
6524  }
6525 
6526  private:
6527  VkFramebuffer m_framebuffer = {};
6528  };
6529 
6530  template <>
6532  {
6534  };
6535 
6536  template <>
6538  {
6540  };
6541 
6542  template <>
6544  {
6546  };
6547 
6549  {
6550  public:
6551  using CType = VkIndirectCommandsLayoutNV;
6552  using NativeType = VkIndirectCommandsLayoutNV;
6553 
6557 
6558  public:
6561  VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
6562  : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV )
6563  {
6564  }
6565 
6566 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6567  IndirectCommandsLayoutNV & operator=( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
6568  {
6569  m_indirectCommandsLayoutNV = indirectCommandsLayoutNV;
6570  return *this;
6571  }
6572 #endif
6573 
6575  {
6576  m_indirectCommandsLayoutNV = {};
6577  return *this;
6578  }
6579 
6580 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6581  auto operator<=>( IndirectCommandsLayoutNV const & ) const = default;
6582 #else
6584  {
6585  return m_indirectCommandsLayoutNV == rhs.m_indirectCommandsLayoutNV;
6586  }
6587 
6589  {
6590  return m_indirectCommandsLayoutNV != rhs.m_indirectCommandsLayoutNV;
6591  }
6592 
6594  {
6595  return m_indirectCommandsLayoutNV < rhs.m_indirectCommandsLayoutNV;
6596  }
6597 #endif
6598 
6599  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT
6600  {
6601  return m_indirectCommandsLayoutNV;
6602  }
6603 
6604  explicit operator bool() const VULKAN_HPP_NOEXCEPT
6605  {
6606  return m_indirectCommandsLayoutNV != VK_NULL_HANDLE;
6607  }
6608 
6610  {
6611  return m_indirectCommandsLayoutNV == VK_NULL_HANDLE;
6612  }
6613 
6614  private:
6615  VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {};
6616  };
6617 
6618  template <>
6620  {
6622  };
6623 
6624  template <>
6626  {
6628  };
6629 
6631  {
6632  public:
6633  using CType = VkPrivateDataSlot;
6634  using NativeType = VkPrivateDataSlot;
6635 
6639 
6640  public:
6643  VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( privateDataSlot ) {}
6644 
6645 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6646  PrivateDataSlot & operator=( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT
6647  {
6648  m_privateDataSlot = privateDataSlot;
6649  return *this;
6650  }
6651 #endif
6652 
6654  {
6655  m_privateDataSlot = {};
6656  return *this;
6657  }
6658 
6659 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6660  auto operator<=>( PrivateDataSlot const & ) const = default;
6661 #else
6663  {
6664  return m_privateDataSlot == rhs.m_privateDataSlot;
6665  }
6666 
6668  {
6669  return m_privateDataSlot != rhs.m_privateDataSlot;
6670  }
6671 
6673  {
6674  return m_privateDataSlot < rhs.m_privateDataSlot;
6675  }
6676 #endif
6677 
6678  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlot() const VULKAN_HPP_NOEXCEPT
6679  {
6680  return m_privateDataSlot;
6681  }
6682 
6683  explicit operator bool() const VULKAN_HPP_NOEXCEPT
6684  {
6685  return m_privateDataSlot != VK_NULL_HANDLE;
6686  }
6687 
6689  {
6690  return m_privateDataSlot == VK_NULL_HANDLE;
6691  }
6692 
6693  private:
6694  VkPrivateDataSlot m_privateDataSlot = {};
6695  };
6696 
6697  template <>
6699  {
6701  };
6702 
6703  template <>
6705  {
6707  };
6709 
6711  {
6712  public:
6713  using CType = VkRenderPass;
6714  using NativeType = VkRenderPass;
6715 
6719 
6720  public:
6721  VULKAN_HPP_CONSTEXPR RenderPass() = default;
6723  VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT : m_renderPass( renderPass ) {}
6724 
6725 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6726  RenderPass & operator=( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT
6727  {
6728  m_renderPass = renderPass;
6729  return *this;
6730  }
6731 #endif
6732 
6734  {
6735  m_renderPass = {};
6736  return *this;
6737  }
6738 
6739 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6740  auto operator<=>( RenderPass const & ) const = default;
6741 #else
6742  bool operator==( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
6743  {
6744  return m_renderPass == rhs.m_renderPass;
6745  }
6746 
6747  bool operator!=( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
6748  {
6749  return m_renderPass != rhs.m_renderPass;
6750  }
6751 
6752  bool operator<( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
6753  {
6754  return m_renderPass < rhs.m_renderPass;
6755  }
6756 #endif
6757 
6759  {
6760  return m_renderPass;
6761  }
6762 
6763  explicit operator bool() const VULKAN_HPP_NOEXCEPT
6764  {
6765  return m_renderPass != VK_NULL_HANDLE;
6766  }
6767 
6769  {
6770  return m_renderPass == VK_NULL_HANDLE;
6771  }
6772 
6773  private:
6774  VkRenderPass m_renderPass = {};
6775  };
6776 
6777  template <>
6779  {
6781  };
6782 
6783  template <>
6785  {
6787  };
6788 
6789  template <>
6791  {
6793  };
6794 
6795  class Sampler
6796  {
6797  public:
6798  using CType = VkSampler;
6799  using NativeType = VkSampler;
6800 
6804 
6805  public:
6806  VULKAN_HPP_CONSTEXPR Sampler() = default;
6809 
6810 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6812  {
6813  m_sampler = sampler;
6814  return *this;
6815  }
6816 #endif
6817 
6819  {
6820  m_sampler = {};
6821  return *this;
6822  }
6823 
6824 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6825  auto operator<=>( Sampler const & ) const = default;
6826 #else
6827  bool operator==( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
6828  {
6829  return m_sampler == rhs.m_sampler;
6830  }
6831 
6832  bool operator!=( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
6833  {
6834  return m_sampler != rhs.m_sampler;
6835  }
6836 
6837  bool operator<( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
6838  {
6839  return m_sampler < rhs.m_sampler;
6840  }
6841 #endif
6842 
6844  {
6845  return m_sampler;
6846  }
6847 
6848  explicit operator bool() const VULKAN_HPP_NOEXCEPT
6849  {
6850  return m_sampler != VK_NULL_HANDLE;
6851  }
6852 
6854  {
6855  return m_sampler == VK_NULL_HANDLE;
6856  }
6857 
6858  private:
6859  VkSampler m_sampler = {};
6860  };
6861 
6862  template <>
6864  {
6866  };
6867 
6868  template <>
6870  {
6872  };
6873 
6874  template <>
6876  {
6878  };
6879 
6881  {
6882  public:
6883  using CType = VkSamplerYcbcrConversion;
6884  using NativeType = VkSamplerYcbcrConversion;
6885 
6889 
6890  public:
6893  VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
6894  : m_samplerYcbcrConversion( samplerYcbcrConversion )
6895  {
6896  }
6897 
6898 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6899  SamplerYcbcrConversion & operator=( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
6900  {
6901  m_samplerYcbcrConversion = samplerYcbcrConversion;
6902  return *this;
6903  }
6904 #endif
6905 
6907  {
6908  m_samplerYcbcrConversion = {};
6909  return *this;
6910  }
6911 
6912 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6913  auto operator<=>( SamplerYcbcrConversion const & ) const = default;
6914 #else
6916  {
6917  return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion;
6918  }
6919 
6921  {
6922  return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion;
6923  }
6924 
6926  {
6927  return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion;
6928  }
6929 #endif
6930 
6931  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT
6932  {
6933  return m_samplerYcbcrConversion;
6934  }
6935 
6936  explicit operator bool() const VULKAN_HPP_NOEXCEPT
6937  {
6938  return m_samplerYcbcrConversion != VK_NULL_HANDLE;
6939  }
6940 
6942  {
6943  return m_samplerYcbcrConversion == VK_NULL_HANDLE;
6944  }
6945 
6946  private:
6947  VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};
6948  };
6949 
6950  template <>
6952  {
6954  };
6955 
6956  template <>
6958  {
6960  };
6961 
6962  template <>
6964  {
6966  };
6968 
6970  {
6971  public:
6972  using CType = VkShaderModule;
6973  using NativeType = VkShaderModule;
6974 
6978 
6979  public:
6980  VULKAN_HPP_CONSTEXPR ShaderModule() = default;
6982  VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT : m_shaderModule( shaderModule ) {}
6983 
6984 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6985  ShaderModule & operator=( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
6986  {
6987  m_shaderModule = shaderModule;
6988  return *this;
6989  }
6990 #endif
6991 
6993  {
6994  m_shaderModule = {};
6995  return *this;
6996  }
6997 
6998 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6999  auto operator<=>( ShaderModule const & ) const = default;
7000 #else
7001  bool operator==( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
7002  {
7003  return m_shaderModule == rhs.m_shaderModule;
7004  }
7005 
7006  bool operator!=( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
7007  {
7008  return m_shaderModule != rhs.m_shaderModule;
7009  }
7010 
7011  bool operator<( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
7012  {
7013  return m_shaderModule < rhs.m_shaderModule;
7014  }
7015 #endif
7016 
7017  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT
7018  {
7019  return m_shaderModule;
7020  }
7021 
7022  explicit operator bool() const VULKAN_HPP_NOEXCEPT
7023  {
7024  return m_shaderModule != VK_NULL_HANDLE;
7025  }
7026 
7028  {
7029  return m_shaderModule == VK_NULL_HANDLE;
7030  }
7031 
7032  private:
7033  VkShaderModule m_shaderModule = {};
7034  };
7035 
7036  template <>
7038  {
7040  };
7041 
7042  template <>
7044  {
7046  };
7047 
7048  template <>
7050  {
7052  };
7053 
7055  {
7056  public:
7057  using CType = VkValidationCacheEXT;
7058  using NativeType = VkValidationCacheEXT;
7059 
7063 
7064  public:
7067  VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( validationCacheEXT )
7068  {
7069  }
7070 
7071 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7072  ValidationCacheEXT & operator=( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
7073  {
7074  m_validationCacheEXT = validationCacheEXT;
7075  return *this;
7076  }
7077 #endif
7078 
7080  {
7081  m_validationCacheEXT = {};
7082  return *this;
7083  }
7084 
7085 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7086  auto operator<=>( ValidationCacheEXT const & ) const = default;
7087 #else
7089  {
7090  return m_validationCacheEXT == rhs.m_validationCacheEXT;
7091  }
7092 
7094  {
7095  return m_validationCacheEXT != rhs.m_validationCacheEXT;
7096  }
7097 
7099  {
7100  return m_validationCacheEXT < rhs.m_validationCacheEXT;
7101  }
7102 #endif
7103 
7104  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const VULKAN_HPP_NOEXCEPT
7105  {
7106  return m_validationCacheEXT;
7107  }
7108 
7109  explicit operator bool() const VULKAN_HPP_NOEXCEPT
7110  {
7111  return m_validationCacheEXT != VK_NULL_HANDLE;
7112  }
7113 
7115  {
7116  return m_validationCacheEXT == VK_NULL_HANDLE;
7117  }
7118 
7119  private:
7120  VkValidationCacheEXT m_validationCacheEXT = {};
7121  };
7122 
7123  template <>
7125  {
7127  };
7128 
7129  template <>
7131  {
7133  };
7134 
7135  template <>
7137  {
7139  };
7140 
7141 #if defined( VK_ENABLE_BETA_EXTENSIONS )
7142  class VideoSessionParametersKHR
7143  {
7144  public:
7145  using CType = VkVideoSessionParametersKHR;
7146  using NativeType = VkVideoSessionParametersKHR;
7147 
7148  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR;
7151 
7152  public:
7153  VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR() = default;
7154  VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7155  VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
7156  : m_videoSessionParametersKHR( videoSessionParametersKHR )
7157  {
7158  }
7159 
7160 # if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7161  VideoSessionParametersKHR & operator=( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
7162  {
7163  m_videoSessionParametersKHR = videoSessionParametersKHR;
7164  return *this;
7165  }
7166 # endif
7167 
7168  VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7169  {
7170  m_videoSessionParametersKHR = {};
7171  return *this;
7172  }
7173 
7174 # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7175  auto operator<=>( VideoSessionParametersKHR const & ) const = default;
7176 # else
7177  bool operator==( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
7178  {
7179  return m_videoSessionParametersKHR == rhs.m_videoSessionParametersKHR;
7180  }
7181 
7182  bool operator!=( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
7183  {
7184  return m_videoSessionParametersKHR != rhs.m_videoSessionParametersKHR;
7185  }
7186 
7187  bool operator<( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
7188  {
7189  return m_videoSessionParametersKHR < rhs.m_videoSessionParametersKHR;
7190  }
7191 # endif
7192 
7193  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT
7194  {
7195  return m_videoSessionParametersKHR;
7196  }
7197 
7198  explicit operator bool() const VULKAN_HPP_NOEXCEPT
7199  {
7200  return m_videoSessionParametersKHR != VK_NULL_HANDLE;
7201  }
7202 
7203  bool operator!() const VULKAN_HPP_NOEXCEPT
7204  {
7205  return m_videoSessionParametersKHR == VK_NULL_HANDLE;
7206  }
7207 
7208  private:
7209  VkVideoSessionParametersKHR m_videoSessionParametersKHR = {};
7210  };
7211 
7212  template <>
7213  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR>
7214  {
7215  using Type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
7216  };
7217 
7218  template <>
7219  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
7220  {
7221  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7222  };
7223 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
7224 
7225  class Queue
7226  {
7227  public:
7228  using CType = VkQueue;
7229  using NativeType = VkQueue;
7230 
7234 
7235  public:
7236  VULKAN_HPP_CONSTEXPR Queue() = default;
7238  Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT : m_queue( queue ) {}
7239 
7241  {
7242  m_queue = queue;
7243  return *this;
7244  }
7245 
7247  {
7248  m_queue = {};
7249  return *this;
7250  }
7251 
7252 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7253  auto operator<=>( Queue const & ) const = default;
7254 #else
7255  bool operator==( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
7256  {
7257  return m_queue == rhs.m_queue;
7258  }
7259 
7260  bool operator!=( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
7261  {
7262  return m_queue != rhs.m_queue;
7263  }
7264 
7265  bool operator<( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
7266  {
7267  return m_queue < rhs.m_queue;
7268  }
7269 #endif
7270 
7271  //=== VK_VERSION_1_0 ===
7272 
7273  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7274  VULKAN_HPP_NODISCARD Result submit( uint32_t submitCount,
7275  const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits,
7278 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7279  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7283  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7284 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7285 
7286 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7287  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7289 #else
7290  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7292 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7293 
7294  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7295  VULKAN_HPP_NODISCARD Result bindSparse( uint32_t bindInfoCount,
7296  const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo,
7299 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7300  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7304  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7305 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7306 
7307  //=== VK_VERSION_1_3 ===
7308 
7309  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7310  VULKAN_HPP_NODISCARD Result submit2( uint32_t submitCount,
7311  const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits,
7314 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7315  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7319  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7320 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7321 
7322  //=== VK_KHR_swapchain ===
7323 
7324  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7327 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7328  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7330  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7331 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7332 
7333  //=== VK_EXT_debug_utils ===
7334 
7335  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7338 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7339  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7342 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7343 
7344  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7346 
7347  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7350 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7351  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7354 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7355 
7356  //=== VK_NV_device_diagnostic_checkpoints ===
7357 
7358  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7359  void getCheckpointDataNV( uint32_t * pCheckpointDataCount,
7360  VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData,
7362 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7363  template <typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>,
7364  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7365  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator>
7367  template <typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>,
7368  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
7369  typename B1 = CheckpointDataNVAllocator,
7370  typename std::enable_if<std::is_same<typename B1::value_type, CheckpointDataNV>::value, int>::type = 0>
7371  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator>
7372  getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7373 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7374 
7375  //=== VK_INTEL_performance_query ===
7376 
7377 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7378  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7381 #else
7382  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7385  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7386 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7387 
7388  //=== VK_KHR_synchronization2 ===
7389 
7390  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7391  VULKAN_HPP_NODISCARD Result submit2KHR( uint32_t submitCount,
7392  const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits,
7395 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7396  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7400  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7401 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7402 
7403  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7404  void getCheckpointData2NV( uint32_t * pCheckpointDataCount,
7405  VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData,
7407 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7408  template <typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>,
7409  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7410  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator>
7412  template <typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>,
7413  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
7414  typename B1 = CheckpointData2NVAllocator,
7415  typename std::enable_if<std::is_same<typename B1::value_type, CheckpointData2NV>::value, int>::type = 0>
7416  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator>
7417  getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7418 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7419 
7420  operator VkQueue() const VULKAN_HPP_NOEXCEPT
7421  {
7422  return m_queue;
7423  }
7424 
7425  explicit operator bool() const VULKAN_HPP_NOEXCEPT
7426  {
7427  return m_queue != VK_NULL_HANDLE;
7428  }
7429 
7431  {
7432  return m_queue == VK_NULL_HANDLE;
7433  }
7434 
7435  private:
7436  VkQueue m_queue = {};
7437  };
7438 
7439  template <>
7441  {
7443  };
7444 
7445  template <>
7447  {
7449  };
7450 
7451  template <>
7453  {
7455  };
7456 
7457 #ifndef VULKAN_HPP_NO_SMART_HANDLE
7458  class Device;
7459  template <typename Dispatch>
7461  {
7462  public:
7464  };
7466  template <typename Dispatch>
7468  {
7469  public:
7471  };
7473  template <typename Dispatch>
7474  class UniqueHandleTraits<Buffer, Dispatch>
7475  {
7476  public:
7478  };
7480 # if defined( VK_USE_PLATFORM_FUCHSIA )
7481  template <typename Dispatch>
7482  class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>
7483  {
7484  public:
7485  using deleter = ObjectDestroy<Device, Dispatch>;
7486  };
7487  using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7488 # endif /*VK_USE_PLATFORM_FUCHSIA*/
7489  template <typename Dispatch>
7491  {
7492  public:
7494  };
7496  template <typename Dispatch>
7498  {
7499  public:
7501  };
7503  template <typename Dispatch>
7505  {
7506  public:
7508  };
7510  template <typename Dispatch>
7512  {
7513  public:
7515  };
7517  template <typename Dispatch>
7519  {
7520  public:
7522  };
7524  template <typename Dispatch>
7526  {
7527  public:
7529  };
7531  template <typename Dispatch>
7533  {
7534  public:
7536  };
7538  template <typename Dispatch>
7540  {
7541  public:
7543  };
7545  template <typename Dispatch>
7547  {
7548  public:
7550  };
7552  template <typename Dispatch>
7554  {
7555  public:
7557  };
7560  template <typename Dispatch>
7562  {
7563  public:
7565  };
7567  template <typename Dispatch>
7568  class UniqueHandleTraits<Event, Dispatch>
7569  {
7570  public:
7572  };
7574  template <typename Dispatch>
7575  class UniqueHandleTraits<Fence, Dispatch>
7576  {
7577  public:
7579  };
7581  template <typename Dispatch>
7583  {
7584  public:
7586  };
7588  template <typename Dispatch>
7589  class UniqueHandleTraits<Image, Dispatch>
7590  {
7591  public:
7593  };
7595  template <typename Dispatch>
7597  {
7598  public:
7600  };
7602  template <typename Dispatch>
7604  {
7605  public:
7607  };
7609  template <typename Dispatch>
7611  {
7612  public:
7614  };
7616  template <typename Dispatch>
7618  {
7619  public:
7621  };
7623  template <typename Dispatch>
7624  class UniqueHandleTraits<Pipeline, Dispatch>
7625  {
7626  public:
7628  };
7630  template <typename Dispatch>
7632  {
7633  public:
7635  };
7637  template <typename Dispatch>
7639  {
7640  public:
7642  };
7644  template <typename Dispatch>
7646  {
7647  public:
7649  };
7652  template <typename Dispatch>
7654  {
7655  public:
7657  };
7659  template <typename Dispatch>
7661  {
7662  public:
7664  };
7666  template <typename Dispatch>
7667  class UniqueHandleTraits<Sampler, Dispatch>
7668  {
7669  public:
7671  };
7673  template <typename Dispatch>
7675  {
7676  public:
7678  };
7681  template <typename Dispatch>
7683  {
7684  public:
7686  };
7688  template <typename Dispatch>
7690  {
7691  public:
7693  };
7695  template <typename Dispatch>
7697  {
7698  public:
7700  };
7702  template <typename Dispatch>
7704  {
7705  public:
7707  };
7709 # if defined( VK_ENABLE_BETA_EXTENSIONS )
7710  template <typename Dispatch>
7711  class UniqueHandleTraits<VideoSessionKHR, Dispatch>
7712  {
7713  public:
7714  using deleter = ObjectDestroy<Device, Dispatch>;
7715  };
7716  using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7717 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
7718 # if defined( VK_ENABLE_BETA_EXTENSIONS )
7719  template <typename Dispatch>
7720  class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>
7721  {
7722  public:
7723  using deleter = ObjectDestroy<Device, Dispatch>;
7724  };
7725  using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7726 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
7727 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7728 
7729  class Device
7730  {
7731  public:
7732  using CType = VkDevice;
7733  using NativeType = VkDevice;
7734 
7738 
7739  public:
7740  VULKAN_HPP_CONSTEXPR Device() = default;
7742  Device( VkDevice device ) VULKAN_HPP_NOEXCEPT : m_device( device ) {}
7743 
7744  Device & operator=( VkDevice device ) VULKAN_HPP_NOEXCEPT
7745  {
7746  m_device = device;
7747  return *this;
7748  }
7749 
7751  {
7752  m_device = {};
7753  return *this;
7754  }
7755 
7756 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7757  auto operator<=>( Device const & ) const = default;
7758 #else
7759  bool operator==( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
7760  {
7761  return m_device == rhs.m_device;
7762  }
7763 
7764  bool operator!=( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
7765  {
7766  return m_device != rhs.m_device;
7767  }
7768 
7769  bool operator<( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
7770  {
7771  return m_device < rhs.m_device;
7772  }
7773 #endif
7774 
7775  //=== VK_VERSION_1_0 ===
7776 
7777  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7778  PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7779 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7780  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7782 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7783 
7784  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7785  void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7787 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7788  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7791 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7792 
7793  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7794  void getQueue( uint32_t queueFamilyIndex,
7795  uint32_t queueIndex,
7796  VULKAN_HPP_NAMESPACE::Queue * pQueue,
7798 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7799  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7801  getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7802 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7803 
7804 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7805  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7807 #else
7808  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7810 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7811 
7812  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7814  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7817 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7818  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7822  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7823 # ifndef VULKAN_HPP_NO_SMART_HANDLE
7824  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7828  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7829 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
7830 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7831 
7832  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7834  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7836 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7837  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7841 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7842 
7843  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7845  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7847 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7848  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7852 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7853 
7854  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7859  void ** ppData,
7861 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7862  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7867  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7868 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7869 
7870  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7872 
7873  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7874  VULKAN_HPP_NODISCARD Result flushMappedMemoryRanges( uint32_t memoryRangeCount,
7875  const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
7877 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7878  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7881  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7882 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7883 
7884  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7885  VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount,
7886  const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
7888 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7889  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7892  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7893 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7894 
7895  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7897  VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes,
7899 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7900  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7903 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7904 
7905 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7906  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7909  VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset,
7911 #else
7912  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7916  VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset,
7917  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7918 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7919 
7920 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7921  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7924  VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset,
7926 #else
7927  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7931  VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset,
7932  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7933 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7934 
7935  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7937  VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
7939 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7940  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7943 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7944 
7945  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7947  VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
7949 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7950  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7953 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7954 
7955  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7957  uint32_t * pSparseMemoryRequirementCount,
7958  VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements,
7960 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7961  template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>,
7962  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7963  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
7965  template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>,
7966  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
7967  typename B1 = SparseImageMemoryRequirementsAllocator,
7968  typename std::enable_if<std::is_same<typename B1::value_type, SparseImageMemoryRequirements>::value, int>::type = 0>
7969  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
7971  SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,
7972  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7973 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7974 
7975  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7977  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7978  VULKAN_HPP_NAMESPACE::Fence * pFence,
7980 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7981  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7985  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7986 # ifndef VULKAN_HPP_NO_SMART_HANDLE
7987  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7991  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7992 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
7993 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7994 
7995  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7997  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7999 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8000  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8004 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8005 
8006  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8008  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8010 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8011  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8015 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8016 
8017  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8018  VULKAN_HPP_NODISCARD Result resetFences( uint32_t fenceCount,
8019  const VULKAN_HPP_NAMESPACE::Fence * pFences,
8021 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8022  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8024  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8025 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8026 
8027 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8028  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8031 #else
8032  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8034  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8035 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8036 
8037  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8038  VULKAN_HPP_NODISCARD Result waitForFences( uint32_t fenceCount,
8039  const VULKAN_HPP_NAMESPACE::Fence * pFences,
8041  uint64_t timeout,
8043 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8044  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8047  uint64_t timeout,
8048  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8049 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8050 
8051  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8053  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8054  VULKAN_HPP_NAMESPACE::Semaphore * pSemaphore,
8056 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8057  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8061  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8062 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8063  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8067  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8068 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8069 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8070 
8071  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8073  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8075 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8076  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8080 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8081 
8082  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8083  void destroy( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
8084  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8086 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8087  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8088  void destroy( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
8091 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8092 
8093  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8095  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8096  VULKAN_HPP_NAMESPACE::Event * pEvent,
8098 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8099  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8103  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8104 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8105  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8109  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8110 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8111 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8112 
8113  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8115  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8117 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8118  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8122 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8123 
8124  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8126  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8128 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8129  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8133 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8134 
8135 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8136  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8139 #else
8140  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8142  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8143 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8144 
8145 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8146  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8149 #else
8150  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8152  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8153 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8154 
8155 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8156  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8159 #else
8160  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8162 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8163 
8164  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8166  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8167  VULKAN_HPP_NAMESPACE::QueryPool * pQueryPool,
8169 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8170  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8174  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8175 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8176  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8180  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8181 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8182 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8183 
8184  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8186  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8188 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8189  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8193 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8194 
8195  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8196  void destroy( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
8197  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8199 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8200  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8201  void destroy( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
8204 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8205 
8206  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8208  uint32_t firstQuery,
8209  uint32_t queryCount,
8210  size_t dataSize,
8211  void * pData,
8215 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8216  template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8219  uint32_t firstQuery,
8220  uint32_t queryCount,
8221  size_t dataSize,
8224  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8225  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8227  uint32_t firstQuery,
8228  uint32_t queryCount,
8231  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8232 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8233 
8234  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8236  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8237  VULKAN_HPP_NAMESPACE::Buffer * pBuffer,
8239 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8240  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8244  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8245 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8246  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8250  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8251 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8252 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8253 
8254  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8256  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8258 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8259  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8263 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8264 
8265  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8267  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8269 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8270  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8274 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8275 
8276  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8278  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8281 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8282  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8286  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8287 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8288  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8292  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8293 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8294 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8295 
8296  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8298  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8300 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8301  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8305 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8306 
8307  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8308  void destroy( VULKAN_HPP_NAMESPACE::BufferView bufferView,
8309  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8311 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8312  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8313  void destroy( VULKAN_HPP_NAMESPACE::BufferView bufferView,
8316 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8317 
8318  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8320  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8321  VULKAN_HPP_NAMESPACE::Image * pImage,
8323 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8324  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8328  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8329 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8330  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8334  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8335 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8336 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8337 
8338  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8340  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8342 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8343  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8347 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8348 
8349  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8351  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8353 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8354  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8358 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8359 
8360  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8362  const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource,
8365 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8366  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8369  const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource,
8371 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8372 
8373  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8375  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8378 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8379  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8383  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8384 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8385  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8389  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8390 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8391 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8392 
8393  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8395  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8397 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8398  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8402 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8403 
8404  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8405  void destroy( VULKAN_HPP_NAMESPACE::ImageView imageView,
8406  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8408 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8409  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8410  void destroy( VULKAN_HPP_NAMESPACE::ImageView imageView,
8413 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8414 
8415  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8417  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8418  VULKAN_HPP_NAMESPACE::ShaderModule * pShaderModule,
8420 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8421  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8425  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8426 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8427  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8431  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8432 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8433 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8434 
8435  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8437  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8439 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8440  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8444 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8445 
8446  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8447  void destroy( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule,
8448  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8450 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8451  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8452  void destroy( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule,
8455 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8456 
8457  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8459  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8460  VULKAN_HPP_NAMESPACE::PipelineCache * pPipelineCache,
8462 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8463  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8467  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8468 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8469  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8473  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8474 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8475 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8476 
8477  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8479  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8481 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8482  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8486 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8487 
8488  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8489  void destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
8490  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8492 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8493  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8494  void destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
8497 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8498 
8499  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8501  size_t * pDataSize,
8502  void * pData,
8504 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8505  template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8508  template <typename Uint8_tAllocator = std::allocator<uint8_t>,
8509  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8510  typename B1 = Uint8_tAllocator,
8511  typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
8514  Uint8_tAllocator & uint8_tAllocator,
8515  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8516 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8517 
8518  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8520  uint32_t srcCacheCount,
8521  const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches,
8523 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8524  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8528  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8529 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8530 
8531  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8533  uint32_t createInfoCount,
8535  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8536  VULKAN_HPP_NAMESPACE::Pipeline * pPipelines,
8538 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8539  template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8544  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8545  template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
8546  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8547  typename B0 = PipelineAllocator,
8548  typename std::enable_if<std::is_same<typename B0::value_type, Pipeline>::value, int>::type = 0>
8553  PipelineAllocator & pipelineAllocator,
8554  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8555  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8560  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8561 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8562  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8563  typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
8568  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8569  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8570  typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
8571  typename B0 = PipelineAllocator,
8572  typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0>
8577  PipelineAllocator & pipelineAllocator,
8578  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8579  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8584  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8585 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8586 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8587 
8588  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8590  uint32_t createInfoCount,
8592  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8593  VULKAN_HPP_NAMESPACE::Pipeline * pPipelines,
8595 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8596  template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8601  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8602  template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
8603  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8604  typename B0 = PipelineAllocator,
8605  typename std::enable_if<std::is_same<typename B0::value_type, Pipeline>::value, int>::type = 0>
8610  PipelineAllocator & pipelineAllocator,
8611  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8612  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8617  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8618 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8619  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8620  typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
8625  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8626  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8627  typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
8628  typename B0 = PipelineAllocator,
8629  typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0>
8634  PipelineAllocator & pipelineAllocator,
8635  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8636  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8641  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8642 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8643 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8644 
8645  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8647  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8649 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8650  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8654 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8655 
8656  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8657  void destroy( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
8658  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8660 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8661  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8662  void destroy( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
8665 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8666 
8667  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8669  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8670  VULKAN_HPP_NAMESPACE::PipelineLayout * pPipelineLayout,
8672 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8673  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8677  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8678 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8679  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8683  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8684 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8685 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8686 
8687  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8689  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8691 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8692  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8696 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8697 
8698  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8699  void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
8700  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8702 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8703  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8704  void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
8707 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8708 
8709  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8711  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8712  VULKAN_HPP_NAMESPACE::Sampler * pSampler,
8714 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8715  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8719  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8720 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8721  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8725  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8726 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8727 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8728 
8729  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8731  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8733 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8734  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8738 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8739 
8740  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8742  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8744 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8745  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8749 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8750 
8751  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8753  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8756 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8757  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8761  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8762 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8763  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8767  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8768 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8769 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8770 
8771  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8773  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8775 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8776  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8780 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8781 
8782  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8783  void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout,
8784  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8786 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8787  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8788  void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout,
8791 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8792 
8793  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8795  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8796  VULKAN_HPP_NAMESPACE::DescriptorPool * pDescriptorPool,
8798 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8799  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8803  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8804 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8805  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8809  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8810 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8811 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8812 
8813  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8815  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8817 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8818  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8822 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8823 
8824  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8825  void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
8826  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8828 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8829  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8830  void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
8833 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8834 
8835 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8836  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8840 #else
8841  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8845 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8846 
8847  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8849  VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
8851 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8852  template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8855  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8856  template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>,
8857  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8858  typename B0 = DescriptorSetAllocator,
8859  typename std::enable_if<std::is_same<typename B0::value_type, DescriptorSet>::value, int>::type = 0>
8862  DescriptorSetAllocator & descriptorSetAllocator,
8863  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8864 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8865  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8866  typename DescriptorSetAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>>
8869  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8870  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8871  typename DescriptorSetAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>,
8872  typename B0 = DescriptorSetAllocator,
8873  typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value, int>::type = 0>
8876  DescriptorSetAllocator & descriptorSetAllocator,
8877  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8878 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8879 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8880 
8881  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8883  uint32_t descriptorSetCount,
8884  const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
8886 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8887  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8891 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8892 
8893  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8895  uint32_t descriptorSetCount,
8896  const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
8898 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8899  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8900  void( free )( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
8903 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8904 
8905  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8906  void updateDescriptorSets( uint32_t descriptorWriteCount,
8907  const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
8908  uint32_t descriptorCopyCount,
8909  const VULKAN_HPP_NAMESPACE::CopyDescriptorSet * pDescriptorCopies,
8911 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8912  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8916 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8917 
8918  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8920  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8921  VULKAN_HPP_NAMESPACE::Framebuffer * pFramebuffer,
8923 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8924  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8928  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8929 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8930  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8934  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8935 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8936 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8937 
8938  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8940  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8942 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8943  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8947 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8948 
8949  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8951  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8953 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8954  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8958 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8959 
8960  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8962  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8963  VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass,
8965 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8966  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8970  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8971 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8972  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8976  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8977 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8978 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8979 
8980  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8982  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8984 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8985  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8989 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8990 
8991  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8992  void destroy( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
8993  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8995 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8996  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8997  void destroy( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
9000 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9001 
9002  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9004  VULKAN_HPP_NAMESPACE::Extent2D * pGranularity,
9006 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9007  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9011 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9012 
9013  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9015  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9016  VULKAN_HPP_NAMESPACE::CommandPool * pCommandPool,
9018 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9019  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9023  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9024 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9025  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9029  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9030 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9031 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9032 
9033  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9035  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9037 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9038  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9042 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9043 
9044  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9045  void destroy( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
9046  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9048 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9049  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9050  void destroy( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
9053 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9054 
9055 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9056  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9060 #else
9061  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9064  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9065 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9066 
9067  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9069  VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
9071 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9072  template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9075  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9076  template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>,
9077  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9078  typename B0 = CommandBufferAllocator,
9079  typename std::enable_if<std::is_same<typename B0::value_type, CommandBuffer>::value, int>::type = 0>
9082  CommandBufferAllocator & commandBufferAllocator,
9083  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9084 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9085  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9086  typename CommandBufferAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>>
9089  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9090  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9091  typename CommandBufferAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>,
9092  typename B0 = CommandBufferAllocator,
9093  typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value, int>::type = 0>
9096  CommandBufferAllocator & commandBufferAllocator,
9097  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9098 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9099 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9100 
9101  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9103  uint32_t commandBufferCount,
9104  const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
9106 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9107  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9111 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9112 
9113  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9115  uint32_t commandBufferCount,
9116  const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
9118 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9119  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9123 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9124 
9125  //=== VK_VERSION_1_1 ===
9126 
9127  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9128  VULKAN_HPP_NODISCARD Result bindBufferMemory2( uint32_t bindInfoCount,
9129  const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
9131 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9132  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9135  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9136 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9137 
9138  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9139  VULKAN_HPP_NODISCARD Result bindImageMemory2( uint32_t bindInfoCount,
9140  const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
9142 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9143  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9146  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9147 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9148 
9149  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9150  void getGroupPeerMemoryFeatures( uint32_t heapIndex,
9151  uint32_t localDeviceIndex,
9152  uint32_t remoteDeviceIndex,
9153  VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
9155 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9156  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9158  getGroupPeerMemoryFeatures( uint32_t heapIndex,
9159  uint32_t localDeviceIndex,
9160  uint32_t remoteDeviceIndex,
9162 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9163 
9164  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9166  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
9168 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9169  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9173  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9177 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9178 
9179  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9181  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
9183 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9184  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9188  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9192 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9193 
9194  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9196  uint32_t * pSparseMemoryRequirementCount,
9197  VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
9199 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9200  template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
9201  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9202  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
9204  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9205  template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
9206  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9207  typename B1 = SparseImageMemoryRequirements2Allocator,
9208  typename std::enable_if<std::is_same<typename B1::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0>
9209  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
9211  SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
9212  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9213 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9214 
9215  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9219 
9220  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9221  void getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo,
9222  VULKAN_HPP_NAMESPACE::Queue * pQueue,
9224 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9225  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9228 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9229 
9230  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9232  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9235 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9236  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9240  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9241 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9242  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9246  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9247 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9248 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9249 
9250  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9252  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9254 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9255  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9259 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9260 
9261  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9263  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9265 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9266  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9270 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9271 
9272  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9274  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9275  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate * pDescriptorUpdateTemplate,
9277 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9278  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9282  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9283 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9284  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9288  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9289 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9290 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9291 
9292  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9294  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9296 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9297  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9301 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9302 
9303  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9304  void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
9305  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9307 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9308  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9309  void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
9312 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9313 
9314  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9316  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
9317  const void * pData,
9319 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9320  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9322  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
9323  DataType const & data,
9325 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9326 
9327  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9331 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9332  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9336  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9340 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9341 
9342  //=== VK_VERSION_1_2 ===
9343 
9344  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9346  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9347  VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass,
9349 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9350  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9354  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9355 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9356  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9360  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9361 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9362 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9363 
9364  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9366  uint32_t firstQuery,
9367  uint32_t queryCount,
9369 
9370  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9372  uint64_t * pValue,
9374 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9375  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9377  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9378 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9379 
9380  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9382  uint64_t timeout,
9384 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9385  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9387  uint64_t timeout,
9388  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9389 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9390 
9391  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9394 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9395  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9398 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9399 
9400  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9403 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9404  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9407 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9408 
9409  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9412 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9413  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9416 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9417 
9418  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9421 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9422  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9425 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9426 
9427  //=== VK_VERSION_1_3 ===
9428 
9429  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9431  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9432  VULKAN_HPP_NAMESPACE::PrivateDataSlot * pPrivateDataSlot,
9434 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9435  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9439  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9440 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9441  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9445  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9446 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9447 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9448 
9449  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9451  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9453 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9454  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9458 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9459 
9460  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9461  void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
9462  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9464 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9465  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9466  void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
9469 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9470 
9471 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9472  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9474  uint64_t objectHandle,
9475  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
9476  uint64_t data,
9478 #else
9479  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9481  uint64_t objectHandle,
9482  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
9483  uint64_t data,
9484  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9485 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9486 
9487  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9489  uint64_t objectHandle,
9490  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
9491  uint64_t * pData,
9493 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9494  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9496  uint64_t objectHandle,
9497  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
9499 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9500 
9501  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9503  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
9505 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9506  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9510  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9514 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9515 
9516  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9518  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
9520 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9521  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9525  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9529 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9530 
9531  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9533  uint32_t * pSparseMemoryRequirementCount,
9534  VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
9536 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9537  template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
9538  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9539  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
9541  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9542  template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
9543  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9544  typename B1 = SparseImageMemoryRequirements2Allocator,
9545  typename std::enable_if<std::is_same<typename B1::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0>
9546  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
9548  SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
9549  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9550 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9551 
9552  //=== VK_KHR_swapchain ===
9553 
9554  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9556  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9559 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9560  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9564  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9565 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9566  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9570  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9571 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9572 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9573 
9574  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9576  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9578 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9579  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9583 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9584 
9585  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9587  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9589 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9590  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9594 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9595 
9596  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9598  uint32_t * pSwapchainImageCount,
9599  VULKAN_HPP_NAMESPACE::Image * pSwapchainImages,
9601 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9602  template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9605  template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>,
9606  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9607  typename B1 = ImageAllocator,
9608  typename std::enable_if<std::is_same<typename B1::value_type, Image>::value, int>::type = 0>
9610  VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, ImageAllocator & imageAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9611 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9612 
9613  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9615  uint64_t timeout,
9618  uint32_t * pImageIndex,
9620 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9621  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9623  uint64_t timeout,
9625  VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9626  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9627 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9628 
9629  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9632 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9633  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9636 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9637 
9638  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9642 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9643  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9646 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9647 
9648  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9650  uint32_t * pImageIndex,
9652 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9653  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9655  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9656 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9657 
9658  //=== VK_KHR_display_swapchain ===
9659 
9660  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9661  VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR( uint32_t swapchainCount,
9662  const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos,
9663  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9664  VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchains,
9666 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9667  template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9671  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9672  template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>,
9673  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9674  typename B0 = SwapchainKHRAllocator,
9675  typename std::enable_if<std::is_same<typename B0::value_type, SwapchainKHR>::value, int>::type = 0>
9679  SwapchainKHRAllocator & swapchainKHRAllocator,
9680  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9681  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9685  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9686 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9687  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9688  typename SwapchainKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>>
9692  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9693  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9694  typename SwapchainKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>,
9695  typename B0 = SwapchainKHRAllocator,
9696  typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value, int>::type = 0>
9700  SwapchainKHRAllocator & swapchainKHRAllocator,
9701  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9702  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9706  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9707 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9708 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9709 
9710  //=== VK_EXT_debug_marker ===
9711 
9712  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9715 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9716  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9719  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9720 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9721 
9722  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9725 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9726  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9729  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9730 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9731 
9732 #if defined( VK_ENABLE_BETA_EXTENSIONS )
9733  //=== VK_KHR_video_queue ===
9734 
9735  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9736  VULKAN_HPP_NODISCARD Result createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo,
9737  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9738  VULKAN_HPP_NAMESPACE::VideoSessionKHR * pVideoSession,
9740 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9741  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9743  createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR & createInfo,
9745  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9746 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9747  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9749  createVideoSessionKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR & createInfo,
9751  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9752 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9753 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9754 
9755  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9756  void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
9757  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9759 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9760  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9761  void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9764 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9765 
9766  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9767  void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
9768  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9770 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9771  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9772  void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
9775 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9776 
9777  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9778  VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
9779  uint32_t * pMemoryRequirementsCount,
9780  VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR * pMemoryRequirements,
9782 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9783  template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>,
9784  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9787  getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
9788  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9789  template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>,
9790  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9791  typename B1 = VideoSessionMemoryRequirementsKHRAllocator,
9792  typename std::enable_if<std::is_same<typename B1::value_type, VideoSessionMemoryRequirementsKHR>::value, int>::type = 0>
9795  getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
9796  VideoSessionMemoryRequirementsKHRAllocator & videoSessionMemoryRequirementsKHRAllocator,
9797  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9798 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9799 
9800  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9801  VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
9802  uint32_t bindSessionMemoryInfoCount,
9803  const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos,
9805 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9806  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9808  bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
9810  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9811 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9812 
9813  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9814  VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo,
9815  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9816  VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR * pVideoSessionParameters,
9818 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9819  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9821  createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR & createInfo,
9823  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9824 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9825  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9827  createVideoSessionParametersKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR & createInfo,
9829  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9830 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9831 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9832 
9833  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9834  VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
9835  const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo,
9837 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9838  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9840  updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
9841  const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo,
9842  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9843 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9844 
9845  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9846  void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
9847  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9849 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9850  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9851  void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9854 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9855 
9856  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9857  void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
9858  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9860 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9861  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9862  void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
9865 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9866 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
9867 
9868  //=== VK_NVX_binary_import ===
9869 
9870  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9872  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9875 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9876  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9880  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9881 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9882  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9886  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9887 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9888 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9889 
9890  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9892  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9895 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9896  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9900  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9901 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9902  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9906  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9907 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9908 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9909 
9910  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9912  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9914 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9915  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9919 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9920 
9921  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9923  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9925 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9926  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9930 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9931 
9932  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9934  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9936 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9937  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9941 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9942 
9943  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9945  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9947 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9948  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9952 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9953 
9954  //=== VK_NVX_image_view_handle ===
9955 
9956  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9959 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9960  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9963 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9964 
9965  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9969 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9970  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9973 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9974 
9975  //=== VK_AMD_shader_info ===
9976 
9977  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9981  size_t * pInfoSize,
9982  void * pInfo,
9984 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9985  template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9990  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9991  template <typename Uint8_tAllocator = std::allocator<uint8_t>,
9992  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9993  typename B1 = Uint8_tAllocator,
9994  typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
9999  Uint8_tAllocator & uint8_tAllocator,
10000  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10001 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10002 
10003 #if defined( VK_USE_PLATFORM_WIN32_KHR )
10004  //=== VK_NV_external_memory_win32 ===
10005 
10006  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10009  HANDLE * pHandle,
10011 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10012  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10015  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10016 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10017 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
10018 
10019  //=== VK_KHR_device_group ===
10020 
10021  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10022  void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex,
10023  uint32_t localDeviceIndex,
10024  uint32_t remoteDeviceIndex,
10025  VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
10027 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10028  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10030  getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex,
10031  uint32_t localDeviceIndex,
10032  uint32_t remoteDeviceIndex,
10034 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10035 
10036  //=== VK_KHR_maintenance1 ===
10037 
10038  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10042 
10043 #if defined( VK_USE_PLATFORM_WIN32_KHR )
10044  //=== VK_KHR_external_memory_win32 ===
10045 
10046  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10047  VULKAN_HPP_NODISCARD Result getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,
10048  HANDLE * pHandle,
10050 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10051  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10053  getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo,
10054  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10055 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10056 
10057  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10059  HANDLE handle,
10060  VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties,
10062 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10063  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10066 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10067 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
10068 
10069  //=== VK_KHR_external_memory_fd ===
10070 
10071  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10073  int * pFd,
10075 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10076  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10078  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10079 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10080 
10081  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10083  int fd,
10084  VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR * pMemoryFdProperties,
10086 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10087  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10090 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10091 
10092 #if defined( VK_USE_PLATFORM_WIN32_KHR )
10093  //=== VK_KHR_external_semaphore_win32 ===
10094 
10095  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10096  VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo,
10098 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10099  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10101  importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo,
10102  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10103 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10104 
10105  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10106  VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
10107  HANDLE * pHandle,
10109 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10110  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10112  getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo,
10113  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10114 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10115 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
10116 
10117  //=== VK_KHR_external_semaphore_fd ===
10118 
10119  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10122 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10123  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10126  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10127 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10128 
10129  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10131  int * pFd,
10133 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10134  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10136  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10137 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10138 
10139  //=== VK_KHR_descriptor_update_template ===
10140 
10141  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10143  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10144  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate * pDescriptorUpdateTemplate,
10146 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10147  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10151  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10152 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10153  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10158  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10159 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10160 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10161 
10162  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10164  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10166 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10167  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10171 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10172 
10173  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10175  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
10176  const void * pData,
10178 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10179  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10181  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
10182  DataType const & data,
10184 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10185 
10186  //=== VK_EXT_display_control ===
10187 
10188  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10190  const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo,
10192 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10193  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10195  const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo,
10196  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10197 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10198 
10199  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10201  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10202  VULKAN_HPP_NAMESPACE::Fence * pFence,
10204 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10205  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10209  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10210 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10211  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10215  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10216 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10217 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10218 
10219  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10221  const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo,
10222  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10223  VULKAN_HPP_NAMESPACE::Fence * pFence,
10225 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10226  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10229  const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT & displayEventInfo,
10231  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10232 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10233  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10236  const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT & displayEventInfo,
10238  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10239 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10240 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10241 
10242  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10245  uint64_t * pCounterValue,
10247 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10248  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10251  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10252 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10253 
10254  //=== VK_GOOGLE_display_timing ===
10255 
10256  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10258  VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties,
10260 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10261  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10264 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10265 
10266  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10268  uint32_t * pPresentationTimingCount,
10271 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10272  template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>,
10273  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10276  template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>,
10277  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10278  typename B1 = PastPresentationTimingGOOGLEAllocator,
10279  typename std::enable_if<std::is_same<typename B1::value_type, PastPresentationTimingGOOGLE>::value, int>::type = 0>
10282  PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,
10283  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10284 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10285 
10286  //=== VK_EXT_hdr_metadata ===
10287 
10288  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10289  void setHdrMetadataEXT( uint32_t swapchainCount,
10290  const VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchains,
10291  const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata,
10293 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10294  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10298 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10299 
10300  //=== VK_KHR_create_renderpass2 ===
10301 
10302  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10304  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10305  VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass,
10307 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10308  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10312  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10313 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10314  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10318  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10319 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10320 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10321 
10322  //=== VK_KHR_shared_presentable_image ===
10323 
10324 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10325  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10328 #else
10329  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10331  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10332 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10333 
10334 #if defined( VK_USE_PLATFORM_WIN32_KHR )
10335  //=== VK_KHR_external_fence_win32 ===
10336 
10337  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10338  VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo,
10340 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10341  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10343  importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo,
10344  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10345 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10346 
10347  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10348  VULKAN_HPP_NODISCARD Result getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,
10349  HANDLE * pHandle,
10351 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10352  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10354  getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo,
10355  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10356 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10357 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
10358 
10359  //=== VK_KHR_external_fence_fd ===
10360 
10361  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10364 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10365  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10368  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10369 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10370 
10371  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10373  int * pFd,
10375 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10376  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10378  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10379 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10380 
10381  //=== VK_KHR_performance_query ===
10382 
10383  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10386 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10387  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10390  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10391 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10392 
10393  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10395 
10396  //=== VK_EXT_debug_utils ===
10397 
10398  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10401 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10402  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10405  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10406 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10407 
10408  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10411 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10412  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10415  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10416 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10417 
10418 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
10419  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
10420 
10421  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10423  getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer * buffer,
10424  VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties,
10426 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10427  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10429  getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10430  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10432  getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10433 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10434 
10435  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10436  VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
10437  struct AHardwareBuffer ** pBuffer,
10439 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10440  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10442  getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info,
10443  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10444 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10445 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
10446 
10447  //=== VK_KHR_get_memory_requirements2 ===
10448 
10449  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10451  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
10453 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10454  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10458  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10462 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10463 
10464  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10466  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
10468 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10469  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10473  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10477 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10478 
10479  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10481  uint32_t * pSparseMemoryRequirementCount,
10482  VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
10484 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10485  template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
10486  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10487  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
10489  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10490  template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
10491  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10492  typename B1 = SparseImageMemoryRequirements2Allocator,
10493  typename std::enable_if<std::is_same<typename B1::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0>
10494  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
10496  SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
10497  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10498 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10499 
10500  //=== VK_KHR_acceleration_structure ===
10501 
10502  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10504  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10505  VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructure,
10507 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10508  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10512  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10513 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10514  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10518  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10519 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10520 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10521 
10522  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10524  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10526 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10527  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10531 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10532 
10533  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10534  void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
10535  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10537 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10538  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10539  void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
10542 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10543 
10544  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10546  uint32_t infoCount,
10548  const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
10550 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10551  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10556  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10557 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10558 
10559  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10563 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10564  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10567  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10568 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10569 
10570  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10574 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10575  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10579  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10580 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10581 
10582  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10586 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10587  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10591  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10592 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10593 
10594  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10596  writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount,
10597  const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
10599  size_t dataSize,
10600  void * pData,
10601  size_t stride,
10603 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10604  template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10608  size_t dataSize,
10609  size_t stride,
10610  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10611  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10615  size_t stride,
10616  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10617 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10618 
10619  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10622 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10623  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10627 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10628 
10629  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10633 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10634  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10638 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10639 
10640  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10643  const uint32_t * pMaxPrimitiveCounts,
10646 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10647  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10653 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10654 
10655  //=== VK_KHR_sampler_ycbcr_conversion ===
10656 
10657  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10659  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10662 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10663  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10667  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10668 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10669  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10673  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10674 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10675 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10676 
10677  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10679  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10681 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10682  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10686 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10687 
10688  //=== VK_KHR_bind_memory2 ===
10689 
10690  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10691  VULKAN_HPP_NODISCARD Result bindBufferMemory2KHR( uint32_t bindInfoCount,
10692  const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
10694 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10695  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10698  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10699 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10700 
10701  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10702  VULKAN_HPP_NODISCARD Result bindImageMemory2KHR( uint32_t bindInfoCount,
10703  const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
10705 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10706  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10709  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10710 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10711 
10712  //=== VK_EXT_image_drm_format_modifier ===
10713 
10714  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10718 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10719  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10722 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10723 
10724  //=== VK_EXT_validation_cache ===
10725 
10726  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10728  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10729  VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pValidationCache,
10731 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10732  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10736  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10737 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10738  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10742  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10743 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10744 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10745 
10746  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10748  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10750 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10751  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10755 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10756 
10757  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10758  void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
10759  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10761 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10762  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10763  void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
10766 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10767 
10768  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10770  uint32_t srcCacheCount,
10771  const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches,
10773 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10774  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10778  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10779 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10780 
10781  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10783  size_t * pDataSize,
10784  void * pData,
10786 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10787  template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10790  template <typename Uint8_tAllocator = std::allocator<uint8_t>,
10791  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10792  typename B1 = Uint8_tAllocator,
10793  typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
10796  Uint8_tAllocator & uint8_tAllocator,
10797  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10798 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10799 
10800  //=== VK_NV_ray_tracing ===
10801 
10802  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10804  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10805  VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructure,
10807 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10808  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10812  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10813 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10814  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10818  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10819 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10820 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10821 
10822  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10824  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10826 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10827  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10831 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10832 
10833  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10834  void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
10835  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10837 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10838  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10839  void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
10842 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10843 
10844  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10846  VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR * pMemoryRequirements,
10848 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10849  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10853  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10857 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10858 
10859  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10863 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10864  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10867  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10868 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10869 
10870  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10872  uint32_t createInfoCount,
10874  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10875  VULKAN_HPP_NAMESPACE::Pipeline * pPipelines,
10877 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10878  template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10883  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10884  template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
10885  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10886  typename B0 = PipelineAllocator,
10887  typename std::enable_if<std::is_same<typename B0::value_type, Pipeline>::value, int>::type = 0>
10892  PipelineAllocator & pipelineAllocator,
10893  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10894  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10899  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10900 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10901  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10902  typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
10907  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10908  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10909  typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
10910  typename B0 = PipelineAllocator,
10911  typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0>
10916  PipelineAllocator & pipelineAllocator,
10917  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10918  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10923  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10924 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10925 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10926 
10927  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10929  uint32_t firstGroup,
10930  uint32_t groupCount,
10931  size_t dataSize,
10932  void * pData,
10934 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10935  template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10938  uint32_t firstGroup,
10939  uint32_t groupCount,
10940  size_t dataSize,
10941  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10942  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10944  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10945 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10946 
10947  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10949  size_t dataSize,
10950  void * pData,
10952 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10953  template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10955  VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10956  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10959  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10960 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10961 
10962 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10963  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10965  uint32_t shader,
10967 #else
10968  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10971 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10972 
10973  //=== VK_KHR_maintenance3 ===
10974 
10975  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10979 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10980  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10984  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10988 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10989 
10990  //=== VK_EXT_external_memory_host ===
10991 
10992  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10994  const void * pHostPointer,
10995  VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties,
10997 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10998  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11001  const void * pHostPointer,
11002  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11003 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11004 
11005  //=== VK_EXT_calibrated_timestamps ===
11006 
11007  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11008  VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT( uint32_t timestampCount,
11009  const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT * pTimestampInfos,
11010  uint64_t * pTimestamps,
11011  uint64_t * pMaxDeviation,
11013 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11014  template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11017  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11018  template <typename Uint64_tAllocator = std::allocator<uint64_t>,
11019  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11020  typename B0 = Uint64_tAllocator,
11021  typename std::enable_if<std::is_same<typename B0::value_type, uint64_t>::value, int>::type = 0>
11024  Uint64_tAllocator & uint64_tAllocator,
11025  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11026  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11029  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11030 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11031 
11032  //=== VK_KHR_timeline_semaphore ===
11033 
11034  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11036  uint64_t * pValue,
11038 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11039  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11042 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11043 
11044  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11046  uint64_t timeout,
11048 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11049  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11051  uint64_t timeout,
11052  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11053 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11054 
11055  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11058 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11059  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11062 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11063 
11064  //=== VK_INTEL_performance_query ===
11065 
11066  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11069 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11070  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11073  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11074 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11075 
11076  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11078 
11079  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11083 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11084  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11087  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11088 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11089  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11092  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11093 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11094 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11095 
11096 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11097  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11100 #else
11101  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11104  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11105 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11106 
11107 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11108  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11111 #else
11112  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11114  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11115 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11116 
11117  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11121 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11122  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11125  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11126 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11127 
11128  //=== VK_AMD_display_native_hdr ===
11129 
11130  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11132  VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable,
11134 
11135  //=== VK_EXT_buffer_device_address ===
11136 
11137  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11140 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11141  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11144 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11145 
11146  //=== VK_KHR_present_wait ===
11147 
11148 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11149  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11151  uint64_t presentId,
11152  uint64_t timeout,
11154 #else
11155  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11157  uint64_t presentId,
11158  uint64_t timeout,
11159  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11160 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11161 
11162 #if defined( VK_USE_PLATFORM_WIN32_KHR )
11163  //=== VK_EXT_full_screen_exclusive ===
11164 
11165 # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11166  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11167  VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11169 # else
11170  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11172  acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11173 # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11174 
11175 # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11176  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11177  VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11179 # else
11180  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11182  releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11183 # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11184 
11185  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11186  VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
11189 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11190  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11192  getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
11193  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11194 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11195 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
11196 
11197  //=== VK_KHR_buffer_device_address ===
11198 
11199  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11202 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11203  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11206 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11207 
11208  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11211 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11212  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11215 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11216 
11217  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11220 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11221  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11224 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11225 
11226  //=== VK_EXT_host_query_reset ===
11227 
11228  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11230  uint32_t firstQuery,
11231  uint32_t queryCount,
11233 
11234  //=== VK_KHR_deferred_host_operations ===
11235 
11236  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11238  VULKAN_HPP_NAMESPACE::DeferredOperationKHR * pDeferredOperation,
11240 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11241  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11244  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11245 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11246  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11249  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11250 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11251 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11252 
11253  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11255  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11257 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11258  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11262 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11263 
11264  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11266  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11268 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11269  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11273 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11274 
11275  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11278 
11279 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11280  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11283 #else
11284  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11288 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11289 
11290 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11291  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11294 #else
11295  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11297  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11298 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11299 
11300  //=== VK_KHR_pipeline_executable_properties ===
11301 
11302  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11304  uint32_t * pExecutableCount,
11307 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11308  template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>,
11309  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11313  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11314  template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>,
11315  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11316  typename B1 = PipelineExecutablePropertiesKHRAllocator,
11317  typename std::enable_if<std::is_same<typename B1::value_type, PipelineExecutablePropertiesKHR>::value, int>::type = 0>
11321  PipelineExecutablePropertiesKHRAllocator & pipelineExecutablePropertiesKHRAllocator,
11322  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11323 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11324 
11325  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11327  uint32_t * pStatisticCount,
11330 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11331  template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>,
11332  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11336  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11337  template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>,
11338  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11339  typename B1 = PipelineExecutableStatisticKHRAllocator,
11340  typename std::enable_if<std::is_same<typename B1::value_type, PipelineExecutableStatisticKHR>::value, int>::type = 0>
11344  PipelineExecutableStatisticKHRAllocator & pipelineExecutableStatisticKHRAllocator,
11345  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11346 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11347 
11348  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11351  uint32_t * pInternalRepresentationCount,
11354 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11355  template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>,
11356  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11358  std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
11360  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11361  template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>,
11362  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11363  typename B1 = PipelineExecutableInternalRepresentationKHRAllocator,
11364  typename std::enable_if<std::is_same<typename B1::value_type, PipelineExecutableInternalRepresentationKHR>::value, int>::type = 0>
11366  std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
11368  const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
11369  PipelineExecutableInternalRepresentationKHRAllocator & pipelineExecutableInternalRepresentationKHRAllocator,
11370  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11371 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11372 
11373  //=== VK_NV_device_generated_commands ===
11374 
11375  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11377  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
11379 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11380  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11384  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11388 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11389 
11390  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11392  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11393  VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV * pIndirectCommandsLayout,
11395 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11396  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11400  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11401 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11402  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11406  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11407 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11408 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11409 
11410  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11412  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11414 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11415  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11419 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11420 
11421  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11422  void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout,
11423  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11425 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11426  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11427  void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout,
11430 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11431 
11432  //=== VK_EXT_private_data ===
11433 
11434  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11436  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11437  VULKAN_HPP_NAMESPACE::PrivateDataSlot * pPrivateDataSlot,
11439 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11440  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11444  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11445 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11446  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11450  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11451 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11452 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11453 
11454  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11456  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11458 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11459  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11463 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11464 
11465 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11466  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11468  uint64_t objectHandle,
11469  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
11470  uint64_t data,
11472 #else
11473  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11475  uint64_t objectHandle,
11476  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
11477  uint64_t data,
11478  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11479 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11480 
11481  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11483  uint64_t objectHandle,
11484  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
11485  uint64_t * pData,
11487 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11488  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11490  uint64_t objectHandle,
11491  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
11493 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11494 
11495 #if defined( VK_USE_PLATFORM_METAL_EXT )
11496  //=== VK_EXT_metal_objects ===
11497 
11498  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11499  void exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT * pMetalObjectsInfo,
11501 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11502  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11503  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT
11504  exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11505  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11507  exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11508 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11509 #endif /*VK_USE_PLATFORM_METAL_EXT*/
11510 
11511  //=== VK_EXT_descriptor_buffer ===
11512 
11513  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11515  VULKAN_HPP_NAMESPACE::DeviceSize * pLayoutSizeInBytes,
11517 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11518  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11522 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11523 
11524  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11526  uint32_t binding,
11529 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11530  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11533  uint32_t binding,
11535 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11536 
11537  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11538  void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT * pDescriptorInfo,
11539  size_t dataSize,
11540  void * pDescriptor,
11542 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11543  template <typename DescriptorType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11546 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11547 
11548  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11551  void * pData,
11553 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11554  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11557  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11558 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11559 
11560  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11562  void * pData,
11564 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11565  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11568  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11569 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11570 
11571  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11574  void * pData,
11576 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11577  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11580  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11581 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11582 
11583  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11586  void * pData,
11588 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11589  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11592  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11593 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11594 
11595  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11598  void * pData,
11600 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11601  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11604  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11605 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11606 
11607  //=== VK_EXT_image_compression_control ===
11608 
11609  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11611  const VULKAN_HPP_NAMESPACE::ImageSubresource2EXT * pSubresource,
11614 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11615  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11618  const VULKAN_HPP_NAMESPACE::ImageSubresource2EXT & subresource,
11620  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11623  const VULKAN_HPP_NAMESPACE::ImageSubresource2EXT & subresource,
11625 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11626 
11627  //=== VK_EXT_device_fault ===
11628 
11629  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11633 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11634  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11636  getFaultInfoEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11637 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11638 
11639  //=== VK_KHR_ray_tracing_pipeline ===
11640 
11641  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11644  uint32_t createInfoCount,
11646  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11647  VULKAN_HPP_NAMESPACE::Pipeline * pPipelines,
11649 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11650  template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11656  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11657  template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
11658  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11659  typename B0 = PipelineAllocator,
11660  typename std::enable_if<std::is_same<typename B0::value_type, Pipeline>::value, int>::type = 0>
11666  PipelineAllocator & pipelineAllocator,
11667  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11668  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11674  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11675 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11676  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11677  typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
11683  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11684  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11685  typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
11686  typename B0 = PipelineAllocator,
11687  typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0>
11693  PipelineAllocator & pipelineAllocator,
11694  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11695  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11701  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11702 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11703 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11704 
11705  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11707  uint32_t firstGroup,
11708  uint32_t groupCount,
11709  size_t dataSize,
11710  void * pData,
11712 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11713  template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11716  uint32_t firstGroup,
11717  uint32_t groupCount,
11718  size_t dataSize,
11719  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11720  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11722  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11723 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11724 
11725  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11728  uint32_t firstGroup,
11729  uint32_t groupCount,
11730  size_t dataSize,
11731  void * pData,
11733 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11734  template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11737  uint32_t firstGroup,
11738  uint32_t groupCount,
11739  size_t dataSize,
11740  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11741  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11743  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11744 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11745 
11746  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11748  uint32_t group,
11751 
11752 #if defined( VK_USE_PLATFORM_FUCHSIA )
11753  //=== VK_FUCHSIA_external_memory ===
11754 
11755  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11756  VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
11757  zx_handle_t * pZirconHandle,
11759 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11760  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11762  getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
11763  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11764 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11765 
11766  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11768  getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
11769  zx_handle_t zirconHandle,
11770  VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties,
11772 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11773  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11775  getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
11776  zx_handle_t zirconHandle,
11777  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11778 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11779 #endif /*VK_USE_PLATFORM_FUCHSIA*/
11780 
11781 #if defined( VK_USE_PLATFORM_FUCHSIA )
11782  //=== VK_FUCHSIA_external_semaphore ===
11783 
11784  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11786  importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo,
11788 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11789  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11791  importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo,
11792  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11793 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11794 
11795  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11796  VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
11797  zx_handle_t * pZirconHandle,
11799 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11800  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11802  getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
11803  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11804 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11805 #endif /*VK_USE_PLATFORM_FUCHSIA*/
11806 
11807 #if defined( VK_USE_PLATFORM_FUCHSIA )
11808  //=== VK_FUCHSIA_buffer_collection ===
11809 
11810  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11811  VULKAN_HPP_NODISCARD Result createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA * pCreateInfo,
11812  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11813  VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA * pCollection,
11815 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11816  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11818  createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA & createInfo,
11820  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11821 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11822  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11824  createBufferCollectionFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA & createInfo,
11826  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11827 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11828 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11829 
11830  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11832  setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
11833  const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo,
11835 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11836  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11838  setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
11839  const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo,
11840  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11841 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11842 
11843  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11845  setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
11846  const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo,
11848 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11849  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11851  setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
11852  const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo,
11853  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11854 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11855 
11856  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11857  void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
11858  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11860 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11861  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11862  void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
11865 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11866 
11867  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11868  void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
11869  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11871 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11872  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11873  void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
11876 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11877 
11878  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11879  VULKAN_HPP_NODISCARD Result getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
11880  VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA * pProperties,
11882 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11883  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11885  getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
11886  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11887 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11888 #endif /*VK_USE_PLATFORM_FUCHSIA*/
11889 
11890  //=== VK_HUAWEI_subpass_shading ===
11891 
11892  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11895  VULKAN_HPP_NAMESPACE::Extent2D * pMaxWorkgroupSize,
11897 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11898  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11901 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11902 
11903  //=== VK_NV_external_memory_rdma ===
11904 
11905  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11909 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11910  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11913  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11914 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11915 
11916  //=== VK_EXT_pipeline_properties ===
11917 
11918  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11920  VULKAN_HPP_NAMESPACE::BaseOutStructure * pPipelineProperties,
11922 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11923  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11926 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11927 
11928  //=== VK_EXT_opacity_micromap ===
11929 
11930  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11932  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11935 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11936  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11940  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11941 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11942  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11946  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11947 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11948 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11949 
11950  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11952  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11954 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11955  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11959 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11960 
11961  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11963  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11965 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11966  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11970 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11971 
11972  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11974  uint32_t infoCount,
11977 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11978  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11982  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11983 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11984 
11985  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11989 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11990  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11993  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11994 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11995 
11996  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12000 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12001  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12004  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12005 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12006 
12007  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12011 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12012  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12015  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12016 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12017 
12018  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12020  const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps,
12022  size_t dataSize,
12023  void * pData,
12024  size_t stride,
12026 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12027  template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12031  size_t dataSize,
12032  size_t stride,
12033  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12034  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12038  size_t stride,
12039  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12040 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12041 
12042  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12046 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12047  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12051 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12052 
12053  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12055  const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pBuildInfo,
12058 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12059  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12064 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12065 
12066  //=== VK_EXT_pageable_device_local_memory ===
12067 
12068  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12070  float priority,
12072 
12073  //=== VK_KHR_maintenance4 ===
12074 
12075  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12077  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
12079 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12080  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12084  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12088 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12089 
12090  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12092  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
12094 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12095  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12099  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12103 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12104 
12105  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12107  uint32_t * pSparseMemoryRequirementCount,
12108  VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
12110 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12111  template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
12112  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12113  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
12115  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12116  template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
12117  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12118  typename B1 = SparseImageMemoryRequirements2Allocator,
12119  typename std::enable_if<std::is_same<typename B1::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0>
12120  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
12122  SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
12123  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12124 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12125 
12126  //=== VK_VALVE_descriptor_set_host_mapping ===
12127 
12128  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12132 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12133  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12137 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12138 
12139  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12141  void ** ppData,
12143 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12144  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12147 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12148 
12149  //=== VK_EXT_shader_module_identifier ===
12150 
12151  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12155 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12156  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12160 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12161 
12162  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12166 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12167  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12171 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12172 
12173  //=== VK_NV_optical_flow ===
12174 
12175  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12177  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12180 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12181  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12185  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12186 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12187  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12191  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12192 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12193 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12194 
12195  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12197  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12199 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12200  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12204 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12205 
12206  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12208  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12210 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12211  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12215 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12216 
12217 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12218  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12224 #else
12225  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12231  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12232 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12233 
12234  //=== VK_QCOM_tile_properties ===
12235 
12236  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12238  uint32_t * pPropertiesCount,
12241 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12242  template <typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>,
12243  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12246  template <typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>,
12247  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12248  typename B1 = TilePropertiesQCOMAllocator,
12249  typename std::enable_if<std::is_same<typename B1::value_type, TilePropertiesQCOM>::value, int>::type = 0>
12252  TilePropertiesQCOMAllocator & tilePropertiesQCOMAllocator,
12253  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12254 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12255 
12256  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12260 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12261  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12265 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12266 
12267  operator VkDevice() const VULKAN_HPP_NOEXCEPT
12268  {
12269  return m_device;
12270  }
12271 
12272  explicit operator bool() const VULKAN_HPP_NOEXCEPT
12273  {
12274  return m_device != VK_NULL_HANDLE;
12275  }
12276 
12278  {
12279  return m_device == VK_NULL_HANDLE;
12280  }
12281 
12282  private:
12283  VkDevice m_device = {};
12284  };
12285 
12286  template <>
12288  {
12290  };
12291 
12292  template <>
12294  {
12296  };
12297 
12298  template <>
12300  {
12302  };
12303 
12305  {
12306  public:
12307  using CType = VkDisplayModeKHR;
12308  using NativeType = VkDisplayModeKHR;
12309 
12313 
12314  public:
12317  VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( displayModeKHR ) {}
12318 
12319 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
12320  DisplayModeKHR & operator=( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
12321  {
12322  m_displayModeKHR = displayModeKHR;
12323  return *this;
12324  }
12325 #endif
12326 
12328  {
12329  m_displayModeKHR = {};
12330  return *this;
12331  }
12332 
12333 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
12334  auto operator<=>( DisplayModeKHR const & ) const = default;
12335 #else
12337  {
12338  return m_displayModeKHR == rhs.m_displayModeKHR;
12339  }
12340 
12342  {
12343  return m_displayModeKHR != rhs.m_displayModeKHR;
12344  }
12345 
12347  {
12348  return m_displayModeKHR < rhs.m_displayModeKHR;
12349  }
12350 #endif
12351 
12352  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT
12353  {
12354  return m_displayModeKHR;
12355  }
12356 
12357  explicit operator bool() const VULKAN_HPP_NOEXCEPT
12358  {
12359  return m_displayModeKHR != VK_NULL_HANDLE;
12360  }
12361 
12363  {
12364  return m_displayModeKHR == VK_NULL_HANDLE;
12365  }
12366 
12367  private:
12368  VkDisplayModeKHR m_displayModeKHR = {};
12369  };
12370 
12371  template <>
12373  {
12375  };
12376 
12377  template <>
12379  {
12381  };
12382 
12383  template <>
12385  {
12387  };
12388 
12389 #ifndef VULKAN_HPP_NO_SMART_HANDLE
12390  template <typename Dispatch>
12391  class UniqueHandleTraits<Device, Dispatch>
12392  {
12393  public:
12395  };
12397 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
12398 
12400  {
12401  public:
12402  using CType = VkPhysicalDevice;
12403  using NativeType = VkPhysicalDevice;
12404 
12408 
12409  public:
12412  PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( physicalDevice ) {}
12413 
12414  PhysicalDevice & operator=( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
12415  {
12416  m_physicalDevice = physicalDevice;
12417  return *this;
12418  }
12419 
12421  {
12422  m_physicalDevice = {};
12423  return *this;
12424  }
12425 
12426 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
12427  auto operator<=>( PhysicalDevice const & ) const = default;
12428 #else
12430  {
12431  return m_physicalDevice == rhs.m_physicalDevice;
12432  }
12433 
12435  {
12436  return m_physicalDevice != rhs.m_physicalDevice;
12437  }
12438 
12440  {
12441  return m_physicalDevice < rhs.m_physicalDevice;
12442  }
12443 #endif
12444 
12445  //=== VK_VERSION_1_0 ===
12446 
12447  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12450 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12451  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12454 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12455 
12456  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12458  VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties,
12460 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12461  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12464 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12465 
12466  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12472  VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties,
12474 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12475  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12482  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12483 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12484 
12485  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12488 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12489  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12492 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12493 
12494  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12495  void getQueueFamilyProperties( uint32_t * pQueueFamilyPropertyCount,
12496  VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties,
12498 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12499  template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>,
12500  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12501  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator>
12503  template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>,
12504  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12505  typename B1 = QueueFamilyPropertiesAllocator,
12506  typename std::enable_if<std::is_same<typename B1::value_type, QueueFamilyProperties>::value, int>::type = 0>
12507  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator>
12508  getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
12509  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12510 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12511 
12512  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12515 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12516  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12519 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12520 
12521  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12523  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12524  VULKAN_HPP_NAMESPACE::Device * pDevice,
12526 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12527  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12531  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12532 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12533  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12537  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12538 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12539 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12540 
12541  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12543  uint32_t * pPropertyCount,
12546 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12547  template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
12548  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12551  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12552  template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
12553  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12554  typename B1 = ExtensionPropertiesAllocator,
12555  typename std::enable_if<std::is_same<typename B1::value_type, ExtensionProperties>::value, int>::type = 0>
12558  ExtensionPropertiesAllocator & extensionPropertiesAllocator,
12559  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12560 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12561 
12562  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12563  VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties( uint32_t * pPropertyCount,
12566 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12567  template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12570  template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>,
12571  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12572  typename B1 = LayerPropertiesAllocator,
12573  typename std::enable_if<std::is_same<typename B1::value_type, LayerProperties>::value, int>::type = 0>
12575  enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12576 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12577 
12578  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12584  uint32_t * pPropertyCount,
12587 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12588  template <typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>,
12589  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12590  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
12596  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12597  template <typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>,
12598  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12599  typename B1 = SparseImageFormatPropertiesAllocator,
12600  typename std::enable_if<std::is_same<typename B1::value_type, SparseImageFormatProperties>::value, int>::type = 0>
12601  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
12607  SparseImageFormatPropertiesAllocator & sparseImageFormatPropertiesAllocator,
12608  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12609 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12610 
12611  //=== VK_VERSION_1_1 ===
12612 
12613  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12616 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12617  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12620  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12622 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12623 
12624  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12627 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12628  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12631  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12633 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12634 
12635  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12637  VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
12639 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12640  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12643  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12646 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12647 
12648  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12650  VULKAN_HPP_NAMESPACE::ImageFormatProperties2 * pImageFormatProperties,
12652 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12653  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12656  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12657  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12660  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12661 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12662 
12663  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12664  void getQueueFamilyProperties2( uint32_t * pQueueFamilyPropertyCount,
12665  VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
12667 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12668  template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
12669  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12670  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
12672  template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
12673  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12674  typename B1 = QueueFamilyProperties2Allocator,
12675  typename std::enable_if<std::is_same<typename B1::value_type, QueueFamilyProperties2>::value, int>::type = 0>
12676  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
12677  getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
12678  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12679  template <typename StructureChain,
12680  typename StructureChainAllocator = std::allocator<StructureChain>,
12681  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12682  VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
12684  template <typename StructureChain,
12685  typename StructureChainAllocator = std::allocator<StructureChain>,
12686  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12687  typename B1 = StructureChainAllocator,
12689  VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
12690  getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12691 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12692 
12693  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12696 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12697  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12700  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12703 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12704 
12705  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12707  uint32_t * pPropertyCount,
12710 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12711  template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
12712  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12713  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
12715  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12716  template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
12717  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12718  typename B1 = SparseImageFormatProperties2Allocator,
12719  typename std::enable_if<std::is_same<typename B1::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
12720  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
12722  SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
12723  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12724 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12725 
12726  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12728  VULKAN_HPP_NAMESPACE::ExternalBufferProperties * pExternalBufferProperties,
12730 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12731  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12735 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12736 
12737  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12739  VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties,
12741 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12742  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12746 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12747 
12748  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12750  VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties * pExternalSemaphoreProperties,
12752 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12753  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12757 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12758 
12759  //=== VK_VERSION_1_3 ===
12760 
12761  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12762  VULKAN_HPP_NODISCARD Result getToolProperties( uint32_t * pToolCount,
12765 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12766  template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
12767  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12769  getToolProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12770  template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
12771  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12772  typename B1 = PhysicalDeviceToolPropertiesAllocator,
12773  typename std::enable_if<std::is_same<typename B1::value_type, PhysicalDeviceToolProperties>::value, int>::type = 0>
12775  getToolProperties( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,
12776  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12777 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12778 
12779  //=== VK_KHR_surface ===
12780 
12781  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12782  VULKAN_HPP_NODISCARD Result getSurfaceSupportKHR( uint32_t queueFamilyIndex,
12784  VULKAN_HPP_NAMESPACE::Bool32 * pSupported,
12786 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12787  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12789  uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12790 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12791 
12792  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12794  VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities,
12796 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12797  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12800 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12801 
12802  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12804  uint32_t * pSurfaceFormatCount,
12805  VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats,
12807 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12808  template <typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>,
12809  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12812  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12813  template <typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>,
12814  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12815  typename B1 = SurfaceFormatKHRAllocator,
12816  typename std::enable_if<std::is_same<typename B1::value_type, SurfaceFormatKHR>::value, int>::type = 0>
12819  SurfaceFormatKHRAllocator & surfaceFormatKHRAllocator,
12820  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12821 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12822 
12823  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12825  uint32_t * pPresentModeCount,
12826  VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes,
12828 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12829  template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12832  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12833  template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>,
12834  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12835  typename B1 = PresentModeKHRAllocator,
12836  typename std::enable_if<std::is_same<typename B1::value_type, PresentModeKHR>::value, int>::type = 0>
12839  PresentModeKHRAllocator & presentModeKHRAllocator,
12840  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12841 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12842 
12843  //=== VK_KHR_swapchain ===
12844 
12845  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12847  uint32_t * pRectCount,
12850 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12851  template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12854  template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>,
12855  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12856  typename B1 = Rect2DAllocator,
12857  typename std::enable_if<std::is_same<typename B1::value_type, Rect2D>::value, int>::type = 0>
12859  VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Rect2DAllocator & rect2DAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12860 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12861 
12862  //=== VK_KHR_display ===
12863 
12864  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12865  VULKAN_HPP_NODISCARD Result getDisplayPropertiesKHR( uint32_t * pPropertyCount,
12868 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12869  template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>,
12870  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12873  template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>,
12874  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12875  typename B1 = DisplayPropertiesKHRAllocator,
12876  typename std::enable_if<std::is_same<typename B1::value_type, DisplayPropertiesKHR>::value, int>::type = 0>
12878  getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator,
12879  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12880 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12881 
12882  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12883  VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR( uint32_t * pPropertyCount,
12886 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12887  template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>,
12888  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12891  template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>,
12892  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12893  typename B1 = DisplayPlanePropertiesKHRAllocator,
12894  typename std::enable_if<std::is_same<typename B1::value_type, DisplayPlanePropertiesKHR>::value, int>::type = 0>
12896  getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator,
12897  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12898 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12899 
12900  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12902  uint32_t * pDisplayCount,
12905 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12906  template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12908  getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12909  template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>,
12910  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12911  typename B1 = DisplayKHRAllocator,
12912  typename std::enable_if<std::is_same<typename B1::value_type, DisplayKHR>::value, int>::type = 0>
12914  uint32_t planeIndex, DisplayKHRAllocator & displayKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12915 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12916 
12917  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12919  uint32_t * pPropertyCount,
12922 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12923  template <typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>,
12924  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12927  template <typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>,
12928  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12929  typename B1 = DisplayModePropertiesKHRAllocator,
12930  typename std::enable_if<std::is_same<typename B1::value_type, DisplayModePropertiesKHR>::value, int>::type = 0>
12933  DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator,
12934  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12935 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12936 
12937  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12940  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12943 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12944  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12949  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12950 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12951  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12956  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12957 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12958 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12959 
12960  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12962  uint32_t planeIndex,
12965 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12966  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12968  VULKAN_HPP_NAMESPACE::DisplayModeKHR mode, uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12969 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12970 
12971 #if defined( VK_USE_PLATFORM_XLIB_KHR )
12972  //=== VK_KHR_xlib_surface ===
12973 
12974  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12975  Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex,
12976  Display * dpy,
12977  VisualID visualID,
12979 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12980  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12981  VULKAN_HPP_NAMESPACE::Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex,
12982  Display & dpy,
12983  VisualID visualID,
12985 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12986 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
12987 
12988 #if defined( VK_USE_PLATFORM_XCB_KHR )
12989  //=== VK_KHR_xcb_surface ===
12990 
12991  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12992  Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex,
12993  xcb_connection_t * connection,
12994  xcb_visualid_t visual_id,
12996 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12997  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12998  VULKAN_HPP_NAMESPACE::Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex,
12999  xcb_connection_t & connection,
13000  xcb_visualid_t visual_id,
13002 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13003 #endif /*VK_USE_PLATFORM_XCB_KHR*/
13004 
13005 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
13006  //=== VK_KHR_wayland_surface ===
13007 
13008  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13009  Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex,
13010  struct wl_display * display,
13012 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13013  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13014  VULKAN_HPP_NAMESPACE::Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex,
13015  struct wl_display & display,
13017 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13018 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
13019 
13020 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13021  //=== VK_KHR_win32_surface ===
13022 
13023  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13024  Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13025 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
13026 
13027 #if defined( VK_ENABLE_BETA_EXTENSIONS )
13028  //=== VK_KHR_video_queue ===
13029 
13030  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13031  VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR * pVideoProfile,
13032  VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR * pCapabilities,
13034 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13035  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13037  getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile,
13038  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13039  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13041  getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile,
13042  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13043 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13044 
13045  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13046  VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
13047  uint32_t * pVideoFormatPropertyCount,
13048  VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR * pVideoFormatProperties,
13050 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13051  template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>,
13052  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13054  getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
13055  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13056  template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>,
13057  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13058  typename B1 = VideoFormatPropertiesKHRAllocator,
13059  typename std::enable_if<std::is_same<typename B1::value_type, VideoFormatPropertiesKHR>::value, int>::type = 0>
13061  getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
13062  VideoFormatPropertiesKHRAllocator & videoFormatPropertiesKHRAllocator,
13063  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13064 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13065 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
13066 
13067  //=== VK_NV_external_memory_capabilities ===
13068 
13069  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13076  VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties,
13078 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13079  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13086  VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
13087  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13088 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13089 
13090  //=== VK_KHR_get_physical_device_properties2 ===
13091 
13092  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13095 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13096  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13099  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13101 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13102 
13103  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13106 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13107  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13110  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13112 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13113 
13114  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13116  VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
13118 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13119  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13122  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13125 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13126 
13127  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13129  VULKAN_HPP_NAMESPACE::ImageFormatProperties2 * pImageFormatProperties,
13131 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13132  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13135  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13136  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13139  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13140 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13141 
13142  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13143  void getQueueFamilyProperties2KHR( uint32_t * pQueueFamilyPropertyCount,
13144  VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
13146 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13147  template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
13148  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13149  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
13151  template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
13152  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13153  typename B1 = QueueFamilyProperties2Allocator,
13154  typename std::enable_if<std::is_same<typename B1::value_type, QueueFamilyProperties2>::value, int>::type = 0>
13155  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
13156  getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
13157  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13158  template <typename StructureChain,
13159  typename StructureChainAllocator = std::allocator<StructureChain>,
13160  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13161  VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
13163  template <typename StructureChain,
13164  typename StructureChainAllocator = std::allocator<StructureChain>,
13165  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13166  typename B1 = StructureChainAllocator,
13168  VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
13169  getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13170 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13171 
13172  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13175 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13176  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13179  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13182 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13183 
13184  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13186  uint32_t * pPropertyCount,
13189 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13190  template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
13191  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13192  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
13194  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13195  template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
13196  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13197  typename B1 = SparseImageFormatProperties2Allocator,
13198  typename std::enable_if<std::is_same<typename B1::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
13199  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
13201  SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
13202  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13203 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13204 
13205  //=== VK_KHR_external_memory_capabilities ===
13206 
13207  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13209  VULKAN_HPP_NAMESPACE::ExternalBufferProperties * pExternalBufferProperties,
13211 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13212  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13216 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13217 
13218  //=== VK_KHR_external_semaphore_capabilities ===
13219 
13220  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13222  VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties * pExternalSemaphoreProperties,
13224 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13225  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13229 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13230 
13231  //=== VK_EXT_direct_mode_display ===
13232 
13233 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13234  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13236 #else
13237  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13239 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13240 
13241 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
13242  //=== VK_EXT_acquire_xlib_display ===
13243 
13244  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13245  VULKAN_HPP_NODISCARD Result acquireXlibDisplayEXT( Display * dpy,
13248 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13249  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13251  acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13252 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13253 
13254  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13255  VULKAN_HPP_NODISCARD Result getRandROutputDisplayEXT( Display * dpy,
13256  RROutput rrOutput,
13259 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13260  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13262  getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13263 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13264  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13266  getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13267 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13268 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13269 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
13270 
13271  //=== VK_EXT_display_surface_counter ===
13272 
13273  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13275  VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities,
13277 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13278  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13281 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13282 
13283  //=== VK_KHR_external_fence_capabilities ===
13284 
13285  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13287  VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties,
13289 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13290  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13294 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13295 
13296  //=== VK_KHR_performance_query ===
13297 
13298  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13300  enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex,
13301  uint32_t * pCounterCount,
13305 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13306  template <typename PerformanceCounterKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>,
13307  typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>,
13308  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13311  std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
13312  enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13313  template <typename PerformanceCounterKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>,
13314  typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>,
13315  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13316  typename B1 = PerformanceCounterKHRAllocator,
13317  typename B2 = PerformanceCounterDescriptionKHRAllocator,
13318  typename std::enable_if<std::is_same<typename B1::value_type, PerformanceCounterKHR>::value &&
13319  std::is_same<typename B2::value_type, PerformanceCounterDescriptionKHR>::value,
13320  int>::type = 0>
13323  std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
13324  enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex,
13325  PerformanceCounterKHRAllocator & performanceCounterKHRAllocator,
13326  PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator,
13327  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13328 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13329 
13330  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13332  uint32_t * pNumPasses,
13334 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13335  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13336  VULKAN_HPP_NODISCARD uint32_t
13339 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13340 
13341  //=== VK_KHR_get_surface_capabilities2 ===
13342 
13343  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13345  VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR * pSurfaceCapabilities,
13347 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13348  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13351  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13352  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13355  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13356 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13357 
13358  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13360  uint32_t * pSurfaceFormatCount,
13361  VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR * pSurfaceFormats,
13363 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13364  template <typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>,
13365  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13368  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13369  template <typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>,
13370  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13371  typename B1 = SurfaceFormat2KHRAllocator,
13372  typename std::enable_if<std::is_same<typename B1::value_type, SurfaceFormat2KHR>::value, int>::type = 0>
13375  SurfaceFormat2KHRAllocator & surfaceFormat2KHRAllocator,
13376  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13377  template <typename StructureChain,
13378  typename StructureChainAllocator = std::allocator<StructureChain>,
13379  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13382  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13383  template <typename StructureChain,
13384  typename StructureChainAllocator = std::allocator<StructureChain>,
13385  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13386  typename B1 = StructureChainAllocator,
13390  StructureChainAllocator & structureChainAllocator,
13391  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13392 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13393 
13394  //=== VK_KHR_get_display_properties2 ===
13395 
13396  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13397  VULKAN_HPP_NODISCARD Result getDisplayProperties2KHR( uint32_t * pPropertyCount,
13400 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13401  template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>,
13402  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13405  template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>,
13406  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13407  typename B1 = DisplayProperties2KHRAllocator,
13408  typename std::enable_if<std::is_same<typename B1::value_type, DisplayProperties2KHR>::value, int>::type = 0>
13410  getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator,
13411  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13412 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13413 
13414  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13415  VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR( uint32_t * pPropertyCount,
13418 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13419  template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>,
13420  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13423  template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>,
13424  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13425  typename B1 = DisplayPlaneProperties2KHRAllocator,
13426  typename std::enable_if<std::is_same<typename B1::value_type, DisplayPlaneProperties2KHR>::value, int>::type = 0>
13428  getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator,
13429  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13430 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13431 
13432  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13434  uint32_t * pPropertyCount,
13437 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13438  template <typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>,
13439  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13442  template <typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>,
13443  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13444  typename B1 = DisplayModeProperties2KHRAllocator,
13445  typename std::enable_if<std::is_same<typename B1::value_type, DisplayModeProperties2KHR>::value, int>::type = 0>
13448  DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator,
13449  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13450 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13451 
13452  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13456 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13457  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13460  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13461 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13462 
13463  //=== VK_EXT_sample_locations ===
13464 
13465  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13467  VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties,
13469 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13470  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13474 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13475 
13476  //=== VK_EXT_calibrated_timestamps ===
13477 
13478  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13479  VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT( uint32_t * pTimeDomainCount,
13480  VULKAN_HPP_NAMESPACE::TimeDomainEXT * pTimeDomains,
13482 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13483  template <typename TimeDomainEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainEXT>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13486  template <typename TimeDomainEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainEXT>,
13487  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13488  typename B1 = TimeDomainEXTAllocator,
13489  typename std::enable_if<std::is_same<typename B1::value_type, TimeDomainEXT>::value, int>::type = 0>
13491  getCalibrateableTimeDomainsEXT( TimeDomainEXTAllocator & timeDomainEXTAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13492 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13493 
13494  //=== VK_KHR_fragment_shading_rate ===
13495 
13496  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13497  VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR( uint32_t * pFragmentShadingRateCount,
13500 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13501  template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>,
13502  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13506  template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>,
13507  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13508  typename B1 = PhysicalDeviceFragmentShadingRateKHRAllocator,
13509  typename std::enable_if<std::is_same<typename B1::value_type, PhysicalDeviceFragmentShadingRateKHR>::value, int>::type = 0>
13512  getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator,
13513  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13514 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13515 
13516  //=== VK_EXT_tooling_info ===
13517 
13518  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13519  VULKAN_HPP_NODISCARD Result getToolPropertiesEXT( uint32_t * pToolCount,
13522 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13523  template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
13524  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13527  template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
13528  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13529  typename B1 = PhysicalDeviceToolPropertiesAllocator,
13530  typename std::enable_if<std::is_same<typename B1::value_type, PhysicalDeviceToolProperties>::value, int>::type = 0>
13532  getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,
13533  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13534 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13535 
13536  //=== VK_NV_cooperative_matrix ===
13537 
13538  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13542 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13543  template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>,
13544  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13548  template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>,
13549  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13550  typename B1 = CooperativeMatrixPropertiesNVAllocator,
13551  typename std::enable_if<std::is_same<typename B1::value_type, CooperativeMatrixPropertiesNV>::value, int>::type = 0>
13554  getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator,
13555  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13556 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13557 
13558  //=== VK_NV_coverage_reduction_mode ===
13559 
13560  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13562  getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t * pCombinationCount,
13565 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13566  template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>,
13567  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13571  template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>,
13572  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13573  typename B1 = FramebufferMixedSamplesCombinationNVAllocator,
13574  typename std::enable_if<std::is_same<typename B1::value_type, FramebufferMixedSamplesCombinationNV>::value, int>::type = 0>
13577  getSupportedFramebufferMixedSamplesCombinationsNV( FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator,
13578  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13579 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13580 
13581 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13582  //=== VK_EXT_full_screen_exclusive ===
13583 
13584  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13585  VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
13586  uint32_t * pPresentModeCount,
13587  VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes,
13589 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13590  template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13592  getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
13593  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13594  template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>,
13595  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13596  typename B1 = PresentModeKHRAllocator,
13597  typename std::enable_if<std::is_same<typename B1::value_type, PresentModeKHR>::value, int>::type = 0>
13599  getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
13600  PresentModeKHRAllocator & presentModeKHRAllocator,
13601  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13602 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13603 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
13604 
13605  //=== VK_EXT_acquire_drm_display ===
13606 
13607 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13608  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13612 #else
13613  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13615  acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13616 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13617 
13618  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13620  uint32_t connectorId,
13623 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13624  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13626  getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13627 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13628  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13630  getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13631 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13632 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13633 
13634 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13635  //=== VK_NV_acquire_winrt_display ===
13636 
13637 # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13638  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13639  VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
13641 # else
13642  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13644  acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13645 # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13646 
13647  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13648  VULKAN_HPP_NODISCARD Result getWinrtDisplayNV( uint32_t deviceRelativeId,
13651 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13652  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13654  getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13655 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13656  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13658  getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13659 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13660 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13661 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
13662 
13663 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
13664  //=== VK_EXT_directfb_surface ===
13665 
13666  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13667  Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex,
13668  IDirectFB * dfb,
13670 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13671  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13672  VULKAN_HPP_NAMESPACE::Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex,
13673  IDirectFB & dfb,
13675 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13676 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
13677 
13678 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
13679  //=== VK_QNX_screen_surface ===
13680 
13681  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13682  Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex,
13683  struct _screen_window * window,
13685 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13686  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13687  VULKAN_HPP_NAMESPACE::Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex,
13688  struct _screen_window & window,
13690 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13691 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
13692 
13693  //=== VK_NV_optical_flow ===
13694 
13695  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13697  uint32_t * pFormatCount,
13700 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13701  template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>,
13702  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13706  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13707  template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>,
13708  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13709  typename B1 = OpticalFlowImageFormatPropertiesNVAllocator,
13710  typename std::enable_if<std::is_same<typename B1::value_type, OpticalFlowImageFormatPropertiesNV>::value, int>::type = 0>
13714  OpticalFlowImageFormatPropertiesNVAllocator & opticalFlowImageFormatPropertiesNVAllocator,
13715  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13716 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13717 
13718  operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT
13719  {
13720  return m_physicalDevice;
13721  }
13722 
13723  explicit operator bool() const VULKAN_HPP_NOEXCEPT
13724  {
13725  return m_physicalDevice != VK_NULL_HANDLE;
13726  }
13727 
13729  {
13730  return m_physicalDevice == VK_NULL_HANDLE;
13731  }
13732 
13733  private:
13734  VkPhysicalDevice m_physicalDevice = {};
13735  };
13736 
13737  template <>
13739  {
13741  };
13742 
13743  template <>
13745  {
13747  };
13748 
13749  template <>
13751  {
13753  };
13754 
13755 #ifndef VULKAN_HPP_NO_SMART_HANDLE
13756  class Instance;
13757  template <typename Dispatch>
13759  {
13760  public:
13762  };
13764  template <typename Dispatch>
13766  {
13767  public:
13769  };
13771  template <typename Dispatch>
13773  {
13774  public:
13776  };
13778 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13779 
13780  class Instance
13781  {
13782  public:
13783  using CType = VkInstance;
13784  using NativeType = VkInstance;
13785 
13789 
13790  public:
13791  VULKAN_HPP_CONSTEXPR Instance() = default;
13793  Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT : m_instance( instance ) {}
13794 
13795  Instance & operator=( VkInstance instance ) VULKAN_HPP_NOEXCEPT
13796  {
13797  m_instance = instance;
13798  return *this;
13799  }
13800 
13802  {
13803  m_instance = {};
13804  return *this;
13805  }
13806 
13807 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
13808  auto operator<=>( Instance const & ) const = default;
13809 #else
13810  bool operator==( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
13811  {
13812  return m_instance == rhs.m_instance;
13813  }
13814 
13815  bool operator!=( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
13816  {
13817  return m_instance != rhs.m_instance;
13818  }
13819 
13820  bool operator<( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
13821  {
13822  return m_instance < rhs.m_instance;
13823  }
13824 #endif
13825 
13826  //=== VK_VERSION_1_0 ===
13827 
13828  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13829  void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13831 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13832  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13835 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13836 
13837  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13838  VULKAN_HPP_NODISCARD Result enumeratePhysicalDevices( uint32_t * pPhysicalDeviceCount,
13839  VULKAN_HPP_NAMESPACE::PhysicalDevice * pPhysicalDevices,
13841 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13842  template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13845  template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>,
13846  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13847  typename B1 = PhysicalDeviceAllocator,
13848  typename std::enable_if<std::is_same<typename B1::value_type, PhysicalDevice>::value, int>::type = 0>
13850  enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13851 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13852 
13853  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13854  PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13855 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13856  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13858 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13859 
13860  //=== VK_VERSION_1_1 ===
13861 
13862  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13863  VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups( uint32_t * pPhysicalDeviceGroupCount,
13864  VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
13866 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13867  template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
13868  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13872  template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
13873  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13874  typename B1 = PhysicalDeviceGroupPropertiesAllocator,
13875  typename std::enable_if<std::is_same<typename B1::value_type, PhysicalDeviceGroupProperties>::value, int>::type = 0>
13878  enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
13879  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13880 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13881 
13882  //=== VK_KHR_surface ===
13883 
13884  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13886  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13888 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13889  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13893 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13894 
13895  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13897  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13899 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13900  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13904 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13905 
13906  //=== VK_KHR_display ===
13907 
13908  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13910  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13913 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13914  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13918  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13919 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13920  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13924  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13925 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13926 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13927 
13928 #if defined( VK_USE_PLATFORM_XLIB_KHR )
13929  //=== VK_KHR_xlib_surface ===
13930 
13931  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13932  VULKAN_HPP_NODISCARD Result createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo,
13933  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13936 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13937  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13939  createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR & createInfo,
13941  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13942 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13943  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13945  createXlibSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR & createInfo,
13947  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13948 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13949 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13950 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
13951 
13952 #if defined( VK_USE_PLATFORM_XCB_KHR )
13953  //=== VK_KHR_xcb_surface ===
13954 
13955  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13956  VULKAN_HPP_NODISCARD Result createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo,
13957  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13960 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13961  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13963  createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR & createInfo,
13965  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13966 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13967  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13969  createXcbSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR & createInfo,
13971  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13972 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13973 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13974 #endif /*VK_USE_PLATFORM_XCB_KHR*/
13975 
13976 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
13977  //=== VK_KHR_wayland_surface ===
13978 
13979  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13980  VULKAN_HPP_NODISCARD Result createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo,
13981  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13984 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13985  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13987  createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR & createInfo,
13989  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13990 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13991  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13993  createWaylandSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR & createInfo,
13995  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13996 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13997 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13998 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
13999 
14000 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
14001  //=== VK_KHR_android_surface ===
14002 
14003  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14004  VULKAN_HPP_NODISCARD Result createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo,
14005  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14008 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14009  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14011  createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR & createInfo,
14013  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14014 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14015  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14017  createAndroidSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR & createInfo,
14019  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14020 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14021 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14022 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
14023 
14024 #if defined( VK_USE_PLATFORM_WIN32_KHR )
14025  //=== VK_KHR_win32_surface ===
14026 
14027  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14028  VULKAN_HPP_NODISCARD Result createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo,
14029  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14032 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14033  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14035  createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR & createInfo,
14037  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14038 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14039  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14041  createWin32SurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR & createInfo,
14043  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14044 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14045 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14046 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
14047 
14048  //=== VK_EXT_debug_report ===
14049 
14050  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14052  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14055 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14056  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14060  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14061 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14062  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14066  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14067 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14068 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14069 
14070  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14072  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14074 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14075  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14079 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14080 
14081  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14083  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14085 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14086  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14090 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14091 
14092  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14095  uint64_t object,
14096  size_t location,
14097  int32_t messageCode,
14098  const char * pLayerPrefix,
14099  const char * pMessage,
14101 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14102  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14105  uint64_t object,
14106  size_t location,
14107  int32_t messageCode,
14108  const std::string & layerPrefix,
14109  const std::string & message,
14111 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14112 
14113 #if defined( VK_USE_PLATFORM_GGP )
14114  //=== VK_GGP_stream_descriptor_surface ===
14115 
14116  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14117  VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
14118  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14121 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14122  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14124  createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP & createInfo,
14126  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14127 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14128  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14130  const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP & createInfo,
14132  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14133 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14134 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14135 #endif /*VK_USE_PLATFORM_GGP*/
14136 
14137 #if defined( VK_USE_PLATFORM_VI_NN )
14138  //=== VK_NN_vi_surface ===
14139 
14140  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14141  VULKAN_HPP_NODISCARD Result createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo,
14142  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14145 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14146  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14148  createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN & createInfo,
14150  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14151 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14152  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14154  createViSurfaceNNUnique( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN & createInfo,
14156  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14157 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14158 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14159 #endif /*VK_USE_PLATFORM_VI_NN*/
14160 
14161  //=== VK_KHR_device_group_creation ===
14162 
14163  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14164  VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR( uint32_t * pPhysicalDeviceGroupCount,
14165  VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
14167 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14168  template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
14169  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14173  template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
14174  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14175  typename B1 = PhysicalDeviceGroupPropertiesAllocator,
14176  typename std::enable_if<std::is_same<typename B1::value_type, PhysicalDeviceGroupProperties>::value, int>::type = 0>
14179  enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
14180  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14181 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14182 
14183 #if defined( VK_USE_PLATFORM_IOS_MVK )
14184  //=== VK_MVK_ios_surface ===
14185 
14186  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14187  VULKAN_HPP_NODISCARD Result createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo,
14188  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14191 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14192  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14194  createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK & createInfo,
14196  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14197 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14198  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14200  createIOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK & createInfo,
14202  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14203 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14204 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14205 #endif /*VK_USE_PLATFORM_IOS_MVK*/
14206 
14207 #if defined( VK_USE_PLATFORM_MACOS_MVK )
14208  //=== VK_MVK_macos_surface ===
14209 
14210  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14211  VULKAN_HPP_NODISCARD Result createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo,
14212  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14215 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14216  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14218  createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK & createInfo,
14220  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14221 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14222  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14224  createMacOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK & createInfo,
14226  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14227 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14228 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14229 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
14230 
14231  //=== VK_EXT_debug_utils ===
14232 
14233  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14235  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14238 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14239  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14243  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14244 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14245  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14249  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14250 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14251 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14252 
14253  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14255  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14257 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14258  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14262 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14263 
14264  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14266  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14268 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14269  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14273 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14274 
14275  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14280 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14281  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14286 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14287 
14288 #if defined( VK_USE_PLATFORM_FUCHSIA )
14289  //=== VK_FUCHSIA_imagepipe_surface ===
14290 
14291  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14292  VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
14293  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14296 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14297  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14299  createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
14301  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14302 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14303  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14305  createImagePipeSurfaceFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
14307  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14308 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14309 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14310 #endif /*VK_USE_PLATFORM_FUCHSIA*/
14311 
14312 #if defined( VK_USE_PLATFORM_METAL_EXT )
14313  //=== VK_EXT_metal_surface ===
14314 
14315  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14316  VULKAN_HPP_NODISCARD Result createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo,
14317  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14320 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14321  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14323  createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT & createInfo,
14325  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14326 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14327  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14329  createMetalSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT & createInfo,
14331  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14332 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14333 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14334 #endif /*VK_USE_PLATFORM_METAL_EXT*/
14335 
14336  //=== VK_EXT_headless_surface ===
14337 
14338  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14340  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14343 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14344  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14348  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14349 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14350  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14354  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14355 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14356 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14357 
14358 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
14359  //=== VK_EXT_directfb_surface ===
14360 
14361  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14362  VULKAN_HPP_NODISCARD Result createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo,
14363  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14366 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14367  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14369  createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT & createInfo,
14371  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14372 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14373  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14375  createDirectFBSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT & createInfo,
14377  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14378 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14379 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14380 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
14381 
14382 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
14383  //=== VK_QNX_screen_surface ===
14384 
14385  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14386  VULKAN_HPP_NODISCARD Result createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo,
14387  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14390 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14391  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14393  createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX & createInfo,
14395  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14396 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14397  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14399  createScreenSurfaceQNXUnique( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX & createInfo,
14401  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14402 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14403 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14404 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
14405 
14406  operator VkInstance() const VULKAN_HPP_NOEXCEPT
14407  {
14408  return m_instance;
14409  }
14410 
14411  explicit operator bool() const VULKAN_HPP_NOEXCEPT
14412  {
14413  return m_instance != VK_NULL_HANDLE;
14414  }
14415 
14417  {
14418  return m_instance == VK_NULL_HANDLE;
14419  }
14420 
14421  private:
14422  VkInstance m_instance = {};
14423  };
14424 
14425  template <>
14427  {
14429  };
14430 
14431  template <>
14433  {
14435  };
14436 
14437  template <>
14439  {
14441  };
14442 
14443  //=== VK_VERSION_1_0 ===
14444 
14445 #ifndef VULKAN_HPP_NO_SMART_HANDLE
14446  template <typename Dispatch>
14447  class UniqueHandleTraits<Instance, Dispatch>
14448  {
14449  public:
14451  };
14453 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14454 
14455  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14457  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14458  VULKAN_HPP_NAMESPACE::Instance * pInstance,
14460 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14461  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14465  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14466 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14467  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14471  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14472 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14473 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14474 
14475  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14477  uint32_t * pPropertyCount,
14480 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14481  template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
14482  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14485  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14486  template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
14487  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14488  typename B1 = ExtensionPropertiesAllocator,
14489  typename std::enable_if<std::is_same<typename B1::value_type, ExtensionProperties>::value, int>::type = 0>
14492  ExtensionPropertiesAllocator & extensionPropertiesAllocator,
14493  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14494 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14495 
14496  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14500 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14501  template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14504  template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>,
14505  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14506  typename B1 = LayerPropertiesAllocator,
14507  typename std::enable_if<std::is_same<typename B1::value_type, LayerProperties>::value, int>::type = 0>
14509  enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14510 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14511 
14512  //=== VK_VERSION_1_1 ===
14513 
14514  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14515  VULKAN_HPP_NODISCARD Result enumerateInstanceVersion( uint32_t * pApiVersion,
14517 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14518  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14520 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14521 
14522 } // namespace VULKAN_HPP_NAMESPACE
14523 #endif
VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups(uint32_t *pPhysicalDeviceGroupCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
GLsizei GLenum GLsizei GLsizei GLuint memory
Definition: RE_OGL.h:202
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
VULKAN_HPP_CONSTEXPR RenderPass(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR DisplayKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void dispatchBaseKHR(uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion(std::nullptr_t) VULKAN_HPP_NOEXCEPT
bool operator==(DescriptorUpdateTemplate const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result importFenceFdKHR(const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR *pImportFenceFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Event & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
uint64_t getMemoryOpaqueCaptureAddressKHR(const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
GLuint GLsizei const GLuint const GLintptr const GLsizeiptr * sizes
Definition: glcorearb.h:2621
void writeAccelerationStructuresPropertiesNV(uint32_t accelerationStructureCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureNV *pAccelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result buildMicromapsEXT(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, uint32_t infoCount, const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT *pInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
DeferredOperationKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
GLenum query
Definition: glad.h:2772
void setViewportWScalingEnableNV(VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getSparseImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, uint32_t *pPresentModeCount, VULKAN_HPP_NAMESPACE::PresentModeKHR *pPresentModes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR DescriptorPool(std::nullptr_t) VULKAN_HPP_NOEXCEPT
AccelerationStructureNV & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
GLuint GLsizei const GLchar * message
Definition: glcorearb.h:2543
VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void getImageMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 *pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyQueryPool(VULKAN_HPP_NAMESPACE::QueryPool queryPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawMeshTasksIndirectEXT(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR ValidationCacheEXT()=default
bool operator!=(ShaderModule const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT *pMessenger, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setPrimitiveTopologyEXT(VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(PerformanceConfigurationINTEL const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR(const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *pYcbcrConversion, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getDescriptorSetLayoutHostMappingInfoVALVE(const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE *pBindingReference, VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE *pHostMapping, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void releaseDisplayEXT(VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyAccelerationStructureNV(VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createDisplayModeKHR(VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::DisplayModeKHR *pMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
GLbitfield flags
Definition: glcorearb.h:1596
void endDebugUtilsLabelEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getQueue(uint32_t queueFamilyIndex, uint32_t queueIndex, VULKAN_HPP_NAMESPACE::Queue *pQueue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
bool operator!=(PipelineLayout const &rhs) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
VULKAN_HPP_NODISCARD Result createSwapchainKHR(const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::SwapchainKHR *pSwapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureKHR(VkAccelerationStructureKHR accelerationStructureKHR) VULKAN_HPP_NOEXCEPT
bool operator!=(DescriptorPool const &rhs) const VULKAN_HPP_NOEXCEPT
void setLineStippleEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(SurfaceKHR const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR(const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR *pStatistics, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result registerEventEXT(const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT *pDeviceEventInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Fence *pFence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(QueryPool const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR AccelerationStructureKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
void pushConstants(VULKAN_HPP_NAMESPACE::PipelineLayout layout, VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(QueryPool const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type setEvent(VULKAN_HPP_NAMESPACE::Event event, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getBufferMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 *pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setLogicOpEXT(VULKAN_HPP_NAMESPACE::LogicOp logicOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getAccelerationStructureMemoryRequirementsNV(const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV *pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setMemoryPriorityEXT(VULKAN_HPP_NAMESPACE::DeviceMemory memory, float priority, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
void decompressMemoryNV(uint32_t decompressRegionCount, const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV *pDecompressMemoryRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Sampler(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void pipelineBarrier(VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VULKAN_HPP_NAMESPACE::MemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *pImageMemoryBarriers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthBounds(float minDepthBounds, float maxDepthBounds, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawMeshTasksEXT(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
#define VK_NULL_HANDLE
Definition: vulkan_core.h:45
VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR(uint32_t planeIndex, uint32_t *pDisplayCount, VULKAN_HPP_NAMESPACE::DisplayKHR *pDisplays, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result deferredOperationJoinKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void traceRaysNV(VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset, VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset, VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride, VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset, VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride, VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset, VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthCompareOp(VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR CuFunctionNVX(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void bindDescriptorSets(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VULKAN_HPP_NAMESPACE::DescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
AccelerationStructureKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void destroyBufferView(VULKAN_HPP_NAMESPACE::BufferView bufferView, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(SamplerYcbcrConversion const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Queue()=default
void setExclusiveScissorNV(uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VULKAN_HPP_NAMESPACE::Rect2D *pExclusiveScissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
#define VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:200
void writeBufferMarker2AMD(VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, uint32_t marker, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setPrimitiveTopology(VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
SwapchainKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getRayTracingCaptureReplayShaderGroupHandleKHR(VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::Sampler, Dispatch > >::type createSamplerUnique(const VULKAN_HPP_NAMESPACE::SamplerCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::QueryPool, Dispatch > >::type createQueryPoolUnique(const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getMemoryFdPropertiesKHR(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd, VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR *pMemoryFdProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getMemoryProperties(VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties *pMemoryProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR DescriptorSetLayout(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void destroySampler(VULKAN_HPP_NAMESPACE::Sampler sampler, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL(const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL *pMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::Fence, Dispatch > >::type registerDisplayEventEXTUnique(VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT &displayEventInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyCommandPool(VULKAN_HPP_NAMESPACE::CommandPool commandPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV()=default
VULKAN_HPP_NODISCARD Result getSwapchainCounterEXT(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter, uint64_t *pCounterValue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getDeferredOperationResultKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
#define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
Definition: vulkan.hpp:205
void setCoverageModulationTableNV(uint32_t coverageModulationTableCount, const float *pCoverageModulationTable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginRenderPass2(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo *pRenderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *pSubpassBeginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(PipelineLayout const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createMicromapEXT(const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::MicromapEXT *pMicromap, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawMultiEXT(uint32_t drawCount, const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT *pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
Y
Definition: ImathEuler.h:184
void writeMicromapsPropertiesEXT(uint32_t micromapCount, const VULKAN_HPP_NAMESPACE::MicromapEXT *pMicromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createPrivateDataSlot(const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::PrivateDataSlot *pPrivateDataSlot, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR DisplayModeKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch >, DescriptorSetAllocator > >::type allocateDescriptorSetsUnique(const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo &allocateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::BufferView, Dispatch > >::type createBufferViewUnique(const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV(VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getRayTracingShaderGroupHandleKHR(VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_CONSTEXPR DeviceMemory(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion(const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *pYcbcrConversion, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setStencilTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(BufferView const &rhs) const VULKAN_HPP_NOEXCEPT
bool operator!=(MicromapEXT const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getBufferOpaqueCaptureDescriptorDataEXT(const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Device(VkDevice device) VULKAN_HPP_NOEXCEPT
bool operator==(SurfaceKHR const &rhs) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
void getImageSubresourceLayout2EXT(VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2EXT *pSubresource, VULKAN_HPP_NAMESPACE::SubresourceLayout2EXT *pLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
bool operator<(SwapchainKHR const &rhs) const VULKAN_HPP_NOEXCEPT
bool operator!=(Semaphore const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory(VkDeviceMemory deviceMemory) VULKAN_HPP_NOEXCEPT
void dispatch(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Fence & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void getPrivateData(VULKAN_HPP_NAMESPACE::ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion()=default
void setProvokingVertexModeEXT(VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void
Definition: png.h:1083
void setViewport(uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::Viewport *pViewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
ResultValueType< void >::type setPrivateData(VULKAN_HPP_NAMESPACE::ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void resolveImage2(const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 *pResolveImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void subpassShadingHUAWEI(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void blitImage2KHR(const VULKAN_HPP_NAMESPACE::BlitImageInfo2 *pBlitImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result allocateDescriptorSets(const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo *pAllocateInfo, VULKAN_HPP_NAMESPACE::DescriptorSet *pDescriptorSets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate()=default
void setHdrMetadataEXT(uint32_t swapchainCount, const VULKAN_HPP_NAMESPACE::SwapchainKHR *pSwapchains, const VULKAN_HPP_NAMESPACE::HdrMetadataEXT *pMetadata, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Framebuffer & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
VULKAN_HPP_NODISCARD Result writeMicromapsPropertiesEXT(uint32_t micromapCount, const VULKAN_HPP_NAMESPACE::MicromapEXT *pMicromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t dataSize, void *pData, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyAccelerationStructureToMemoryKHR(const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getFenceStatus(VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result flushMappedMemoryRanges(uint32_t memoryRangeCount, const VULKAN_HPP_NAMESPACE::MappedMemoryRange *pMemoryRanges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginTransformFeedbackEXT(uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VULKAN_HPP_NAMESPACE::Buffer *pCounterBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize *pCounterBufferOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL(VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter, VULKAN_HPP_NAMESPACE::PerformanceValueINTEL *pValue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createFramebuffer(const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Framebuffer *pFramebuffer, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(DebugReportCallbackEXT const &rhs) const VULKAN_HPP_NOEXCEPT
void beginConditionalRenderingEXT(const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Instance & operator=(VkInstance instance) VULKAN_HPP_NOEXCEPT
bool operator==(Semaphore const &rhs) const VULKAN_HPP_NOEXCEPT
void bindDescriptorBufferEmbeddedSamplersEXT(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch > >::type createAccelerationStructureKHRUnique(const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void endRenderPass(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getDescriptorSetHostMappingVALVE(VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, void **ppData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
VULKAN_HPP_NODISCARD Result begin(const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo *pBeginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endRenderPass2KHR(const VULKAN_HPP_NAMESPACE::SubpassEndInfo *pSubpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch > >::type createDebugUtilsMessengerEXTUnique(const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
bool operator!() const VULKAN_HPP_NOEXCEPT
PFN_vkVoidFunction getProcAddr(const char *pName, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result acquireNextImage2KHR(const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR ImageView(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void updateDescriptorSets(uint32_t descriptorWriteCount, const VULKAN_HPP_NAMESPACE::WriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VULKAN_HPP_NAMESPACE::CopyDescriptorSet *pDescriptorCopies, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createDescriptorPool(const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::DescriptorPool *pDescriptorPool, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
GLsizei const GLchar *const * string
Definition: glcorearb.h:814
VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV(const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV *pIndirectCommandsLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
GLsizei const GLfloat * value
Definition: glcorearb.h:824
VULKAN_HPP_CONSTEXPR Buffer(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void getDescriptorSetLayoutSupport(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo *pCreateInfo, VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *pSupport, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch > >::type createSamplerYcbcrConversionKHRUnique(const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result waitSemaphores(const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo *pWaitInfo, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getDisplayPropertiesKHR(uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawMultiIndexedEXT(uint32_t drawCount, const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT *pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t *pVertexOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(DescriptorUpdateTemplate const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result submit(uint32_t submitCount, const VULKAN_HPP_NAMESPACE::SubmitInfo *pSubmits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setColorBlendEnableEXT(uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::Bool32 *pColorBlendEnables, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void setPolygonModeEXT(VULKAN_HPP_NAMESPACE::PolygonMode polygonMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void resetEvent2KHR(VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
DeviceAddress getBufferAddressKHR(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyFramebuffer(VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setVertexInputEXT(uint32_t vertexBindingDescriptionCount, const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT *pVertexAttributeDescriptions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setViewportShadingRatePaletteNV(uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV *pShadingRatePalettes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void updateDescriptorSetWithTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR(VULKAN_HPP_NAMESPACE::DisplayModeKHR mode, uint32_t planeIndex, VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR *pCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(Instance const &rhs) const VULKAN_HPP_NOEXCEPT
void getQueueFamilyPerformanceQueryPassesKHR(const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyDescriptorUpdateTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
bool operator<(Pipeline const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch > >::type createSharedSwapchainKHRUnique(const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR(uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch > >::type createDisplayPlaneSurfaceKHRUnique(const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
Buffer & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain< X, Y, Z...> getFeatures2() const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
void copyQueryPoolResults(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result resetFences(uint32_t fenceCount, const VULKAN_HPP_NAMESPACE::Fence *pFences, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV *pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Pipeline *pPipelines, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
GLuint64 GLenum handleType
Definition: RE_OGL.h:262
void copyBuffer2(const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 *pCopyBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR PipelineCache(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void clearColorImage(VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, const VULKAN_HPP_NAMESPACE::ClearColorValue *pColor, uint32_t rangeCount, const VULKAN_HPP_NAMESPACE::ImageSubresourceRange *pRanges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setRasterizerDiscardEnable(VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void opticalFlowExecuteNV(VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV *pExecuteInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule(VkShaderModule shaderModule) VULKAN_HPP_NOEXCEPT
void destroyDescriptorPool(VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(DescriptorUpdateTemplate const &rhs) const VULKAN_HPP_NOEXCEPT
void getImageSubresourceLayout(VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource *pSubresource, VULKAN_HPP_NAMESPACE::SubresourceLayout *pLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(DebugReportCallbackEXT const &rhs) const VULKAN_HPP_NOEXCEPT
bool operator==(DescriptorSet const &rhs) const VULKAN_HPP_NOEXCEPT
void bindVertexBuffers2EXT(uint32_t firstBinding, uint32_t bindingCount, const VULKAN_HPP_NAMESPACE::Buffer *pBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize *pOffsets, const VULKAN_HPP_NAMESPACE::DeviceSize *pSizes, const VULKAN_HPP_NAMESPACE::DeviceSize *pStrides, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result mergeValidationCachesEXT(VULKAN_HPP_NAMESPACE::ValidationCacheEXT dstCache, uint32_t srcCacheCount, const VULKAN_HPP_NAMESPACE::ValidationCacheEXT *pSrcCaches, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setRasterizerDiscardEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
PrivateDataSlot & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
ImageView & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceVersion(uint32_t *pApiVersion, Dispatch const &d) VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
void copyMemoryIndirectNV(VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void resetEvent(VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
uint64_t DeviceAddress
Definition: vulkan.hpp:6074
void setEvent2KHR(VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo *pDependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getExternalBufferPropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VULKAN_HPP_NAMESPACE::ExternalBufferProperties *pExternalBufferProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Image & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void resetQueryPool(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(Framebuffer const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Image(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch > >::type createCuFunctionNVXUnique(const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindBufferMemory(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX(VkCuFunctionNVX cuFunctionNVX) VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
void setViewportSwizzleNV(uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV *pViewportSwizzles, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForPresentKHR(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyPrivateDataSlotEXT(VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setFragmentShadingRateEnumNV(VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate, const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
bool operator!() const VULKAN_HPP_NOEXCEPT
void beginDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(Fence const &rhs) const VULKAN_HPP_NOEXCEPT
void updateDescriptorSetWithTemplate(VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createDevice(const VULKAN_HPP_NAMESPACE::DeviceCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Device *pDevice, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getFormatProperties2(VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties2 *pFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *pImageFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch > >::type allocateMemoryUnique(const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo &allocateInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getShaderModuleIdentifierEXT(VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT *pIdentifier, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(RenderPass const &rhs) const VULKAN_HPP_NOEXCEPT
bool operator!=(DisplayKHR const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getToolProperties(uint32_t *pToolCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties *pToolProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
X
Definition: ImathEuler.h:183
VULKAN_HPP_CONSTEXPR QueryPool(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Result getDynamicRenderingTilePropertiesQCOM(const VULKAN_HPP_NAMESPACE::RenderingInfo *pRenderingInfo, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void blitImage(VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::ImageBlit *pRegions, VULKAN_HPP_NAMESPACE::Filter filter, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch > >::type createDescriptorSetLayoutUnique(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void beginQueryIndexedEXT(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, VULKAN_HPP_NAMESPACE::QueryControlFlags flags, uint32_t index, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(BufferView const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR DescriptorSet(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT Fence(VkFence fence) VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
bool operator!=(DebugUtilsMessengerEXT const &rhs) const VULKAN_HPP_NOEXCEPT
void bindIndexBuffer(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::IndexType indexType, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindVertexBuffers(uint32_t firstBinding, uint32_t bindingCount, const VULKAN_HPP_NAMESPACE::Buffer *pBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize *pOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch > >::type createPipelineCacheUnique(const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
bool operator<(Semaphore const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot(VkPrivateDataSlot privateDataSlot) VULKAN_HPP_NOEXCEPT
bool operator<(RenderPass const &rhs) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
VULKAN_HPP_CONSTEXPR DescriptorPool()=default
GLenum GLenum GLsizei void * image
Definition: glad.h:5132
void endConditionalRenderingEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getCheckpointDataNV(uint32_t *pCheckpointDataCount, VULKAN_HPP_NAMESPACE::CheckpointDataNV *pCheckpointData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch > >::type createDescriptorUpdateTemplateUnique(const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void setPrimitiveRestartEnable(VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR ValidationCacheEXT(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void setViewportWScalingNV(uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::ViewportWScalingNV *pViewportWScalings, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthBoundsTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getGeneratedCommandsMemoryRequirementsNV(const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV *pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(CommandBuffer const &rhs) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
bool operator!=(CuFunctionNVX const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR CuFunctionNVX()=default
VULKAN_HPP_NODISCARD Result getMemoryFdKHR(const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR *pGetFdInfo, int *pFd, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(RenderPass const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR(VULKAN_HPP_NAMESPACE::DisplayKHR display, uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setColorBlendAdvancedEXT(uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT *pColorBlendAdvanced, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
VULKAN_HPP_CONSTEXPR DisplayModeKHR()=default
void setPrimitiveRestartEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
SamplerYcbcrConversion & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
GLuint sampler
Definition: glcorearb.h:1656
bool operator==(AccelerationStructureNV const &rhs) const VULKAN_HPP_NOEXCEPT
void drawMeshTasksNV(uint32_t taskCount, uint32_t firstTask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Instance()=default
VULKAN_HPP_NODISCARD Result getPresentRectanglesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, uint32_t *pRectCount, VULKAN_HPP_NAMESPACE::Rect2D *pRects, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
bool operator!=(Event const &rhs) const VULKAN_HPP_NOEXCEPT
bool operator!=(PrivateDataSlot const &rhs) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< VULKAN_HPP_NAMESPACE::Pipeline, Dispatch >, PipelineAllocator > > createGraphicsPipelinesUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy< const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo > const &createInfos, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT(uint32_t *pTimeDomainCount, VULKAN_HPP_NAMESPACE::TimeDomainEXT *pTimeDomains, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
PhysicalDevice(VkPhysicalDevice physicalDevice) VULKAN_HPP_NOEXCEPT
Queue(VkQueue queue) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result acquireNextImageKHR(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t timeout, VULKAN_HPP_NAMESPACE::Semaphore semaphore, VULKAN_HPP_NAMESPACE::Fence fence, uint32_t *pImageIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(Image const &rhs) const VULKAN_HPP_NOEXCEPT
void getMemoryCommitment(VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize *pCommittedMemoryInBytes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR(const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR *pDisplayPlaneInfo, VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR *pCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void debugMarkerInsertEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT *pMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getFormatProperties(VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties *pFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR *pSurfaceCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Queue & operator=(VkQueue queue) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout) VULKAN_HPP_NOEXCEPT
Queue & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
void getGroupPeerMemoryFeatures(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags *pPeerMemoryFeatures, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
GLuint buffer
Definition: glcorearb.h:660
bool operator!() const VULKAN_HPP_NOEXCEPT
bool operator<(DescriptorSetLayout const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch > >::type createPrivateDataSlotUnique(const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createBuffer(const VULKAN_HPP_NAMESPACE::BufferCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Buffer *pBuffer, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(Queue const &rhs) const VULKAN_HPP_NOEXCEPT
void writeAccelerationStructuresPropertiesKHR(uint32_t accelerationStructureCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *pAccelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL(const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL *pOverrideInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawIndexedIndirectCount(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void debugMarkerEndEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
DisplayKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void traceRaysIndirect2KHR(VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(AccelerationStructureKHR const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool(VkQueryPool queryPool) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer(VkFramebuffer framebuffer) VULKAN_HPP_NOEXCEPT
void setCoverageModulationModeNV(VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void buildAccelerationStructuresKHR(uint32_t infoCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *pInfos, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void dispatchBase(uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void writeTimestamp(VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch > >::type createIndirectCommandsLayoutNVUnique(const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR(const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *pDescriptorUpdateTemplate, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL(const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL *pConfiguration, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR BufferView()=default
bool operator!=(CuModuleNVX const &rhs) const VULKAN_HPP_NOEXCEPT
bool operator==(Event const &rhs) const VULKAN_HPP_NOEXCEPT
void setDepthBiasEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Fence(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void destroyShaderModule(VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(Sampler const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getPipelineCacheData(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, size_t *pDataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR DisplayKHR()=default
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
void destroyPipeline(VULKAN_HPP_NAMESPACE::Pipeline pipeline, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR DeviceMemory()=default
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::RenderPass, Dispatch > >::type createRenderPass2KHRUnique(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
bool operator==(Device const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result submit2(uint32_t submitCount, const VULKAN_HPP_NAMESPACE::SubmitInfo2 *pSubmits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
uint64_t getBufferOpaqueCaptureAddressKHR(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR *pSurfaceCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result copyMicromapEXT(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endRenderPass2(const VULKAN_HPP_NAMESPACE::SubpassEndInfo *pSubpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain< X, Y, Z...> getProperties2KHR() const VULKAN_HPP_NOEXCEPT
bool operator==(MicromapEXT const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getEventStatus(VULKAN_HPP_NAMESPACE::Event event, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
GLuint GLsizei const GLuint const GLintptr * offsets
Definition: glcorearb.h:2621
void copyBufferToImage2(const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 *pCopyBufferToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getPrivateDataEXT(VULKAN_HPP_NAMESPACE::ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void cuLaunchKernelNVX(const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX *pLaunchInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT Sampler(VkSampler sampler) VULKAN_HPP_NOEXCEPT
void drawIndirect(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
struct _cl_event * event
Definition: glcorearb.h:2961
VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR(VkSwapchainKHR swapchainKHR) VULKAN_HPP_NOEXCEPT
void getExternalSemaphorePropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *pExternalSemaphoreProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDescriptorDataEXT(const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< VULKAN_HPP_NAMESPACE::Pipeline, Dispatch >, PipelineAllocator > > createComputePipelinesUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy< const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo > const &createInfos, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT(uint32_t timestampCount, const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void blitImage2(const VULKAN_HPP_NAMESPACE::BlitImageInfo2 *pBlitImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type waitIdle(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
bool operator==(IndirectCommandsLayoutNV const &rhs) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE *pDisplayTimingProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(DebugUtilsMessengerEXT const &rhs) const VULKAN_HPP_NOEXCEPT
DebugUtilsMessengerEXT & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT Buffer(VkBuffer buffer) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR MicromapEXT(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void copyBufferToImage(VULKAN_HPP_NAMESPACE::Buffer srcBuffer, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::BufferImageCopy *pRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setRasterizationSamplesEXT(VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT(VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch > >::type getDrmDisplayEXTUnique(int32_t drmFd, uint32_t connectorId, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_CONSTEXPR Device()=default
void getGroupPeerMemoryFeaturesKHR(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags *pPeerMemoryFeatures, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
DeviceAddress getBufferAddress(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setStencilCompareMask(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch > >::type createSamplerYcbcrConversionUnique(const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet(VkDescriptorSet descriptorSet) VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getRayTracingShaderGroupHandleNV(VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
bool operator!=(DeviceMemory const &rhs) const VULKAN_HPP_NOEXCEPT
void getBufferMemoryRequirements(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::MemoryRequirements *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(Fence const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getImageViewOpaqueCaptureDescriptorDataEXT(const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::Buffer, Dispatch > >::type createBufferUnique(const VULKAN_HPP_NAMESPACE::BufferCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_CONSTEXPR QueryPool()=default
VULKAN_HPP_CONSTEXPR DescriptorSet()=default
bool operator!() const VULKAN_HPP_NOEXCEPT
GLint GLsizei GLsizei height
Definition: glcorearb.h:103
VULKAN_HPP_NODISCARD ResultValue< UniqueHandle< VULKAN_HPP_NAMESPACE::Pipeline, Dispatch > > createGraphicsPipelineUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
bool operator!=(BufferView const &rhs) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
bool operator!() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR(const VULKAN_HPP_NAMESPACE::PipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(Queue const &rhs) const VULKAN_HPP_NOEXCEPT
void destroyCuModuleNVX(VULKAN_HPP_NAMESPACE::CuModuleNVX module, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(PhysicalDevice const &rhs) const VULKAN_HPP_NOEXCEPT
void drawMeshTasksIndirectCountEXT(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(std::string const &lhs, ArrayWrapper1D< char, N > const &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:330
VULKAN_HPP_NODISCARD Result bindSparse(uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindSparseInfo *pBindInfo, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindTransformFeedbackBuffersEXT(uint32_t firstBinding, uint32_t bindingCount, const VULKAN_HPP_NAMESPACE::Buffer *pBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize *pOffsets, const VULKAN_HPP_NAMESPACE::DeviceSize *pSizes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endTransformFeedbackEXT(uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VULKAN_HPP_NAMESPACE::Buffer *pCounterBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize *pCounterBufferOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch > >::type createDeferredOperationKHRUnique(Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
#define VULKAN_HPP_CONST_OR_CONSTEXPR
Definition: vulkan.hpp:193
void setCoverageReductionModeNV(VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getImageSparseMemoryRequirements(VULKAN_HPP_NAMESPACE::Image image, uint32_t *pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements *pSparseMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createSampler(const VULKAN_HPP_NAMESPACE::SamplerCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Sampler *pSampler, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createCuModuleNVX(const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::CuModuleNVX *pModule, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setAlphaToOneEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
GLuint framebuffer
Definition: glcorearb.h:1287
bool operator!=(PerformanceConfigurationINTEL const &rhs) const VULKAN_HPP_NOEXCEPT
void waitEvents2KHR(uint32_t eventCount, const VULKAN_HPP_NAMESPACE::Event *pEvents, const VULKAN_HPP_NAMESPACE::DependencyInfo *pDependencyInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(DescriptorSetLayout const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createRenderPass2KHR(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::RenderPass *pRenderPass, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroySemaphore(VULKAN_HPP_NAMESPACE::Semaphore semaphore, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
#define VULKAN_HPP_CONSTEXPR
Definition: vulkan.hpp:191
bool operator<(DebugUtilsMessengerEXT const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createPipelineLayout(const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::PipelineLayout *pPipelineLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setLocalDimmingAMD(VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain, VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getPipelinePropertiesEXT(const VULKAN_HPP_NAMESPACE::PipelineInfoEXT *pPipelineInfo, VULKAN_HPP_NAMESPACE::BaseOutStructure *pPipelineProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
GLintptr offset
Definition: glcorearb.h:665
void pushDescriptorSetKHR(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VULKAN_HPP_NAMESPACE::WriteDescriptorSet *pDescriptorWrites, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(ShaderModule const &rhs) const VULKAN_HPP_NOEXCEPT
void setDepthClipEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getMicromapBuildSizesEXT(VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT *pBuildInfo, VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT *pSizeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(DisplayModeKHR const &rhs) const VULKAN_HPP_NOEXCEPT
void getSparseImageFormatProperties(VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageTiling tiling, uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(DisplayModeKHR const &rhs) const VULKAN_HPP_NOEXCEPT
void unmapMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getShaderModuleCreateInfoIdentifierEXT(const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo *pCreateInfo, VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT *pIdentifier, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Definition: core.h:760
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
void getDescriptorSetLayoutBindingOffsetEXT(VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, uint32_t binding, VULKAN_HPP_NAMESPACE::DeviceSize *pOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
#define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
Definition: vulkan.hpp:225
void destroyDeferredOperationKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(ImageView const &rhs) const VULKAN_HPP_NOEXCEPT
void buildAccelerationStructureNV(const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV *pInfo, VULKAN_HPP_NAMESPACE::Buffer instanceData, VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, VULKAN_HPP_NAMESPACE::Bool32 update, VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, VULKAN_HPP_NAMESPACE::Buffer scratch, VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline(VkPipeline pipeline) VULKAN_HPP_NOEXCEPT
void getImageMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 *pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT(const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT *pCallback, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(Event const &rhs) const VULKAN_HPP_NOEXCEPT
bool operator<(Device const &rhs) const VULKAN_HPP_NOEXCEPT
bool operator<(MicromapEXT const &rhs) const VULKAN_HPP_NOEXCEPT
bool operator==(CommandBuffer const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getSubpassShadingMaxWorkgroupSizeHUAWEI(VULKAN_HPP_NAMESPACE::RenderPass renderpass, VULKAN_HPP_NAMESPACE::Extent2D *pMaxWorkgroupSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result enumeratePhysicalDevices(uint32_t *pPhysicalDeviceCount, VULKAN_HPP_NAMESPACE::PhysicalDevice *pPhysicalDevices, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getRenderAreaGranularity(VULKAN_HPP_NAMESPACE::RenderPass renderPass, VULKAN_HPP_NAMESPACE::Extent2D *pGranularity, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
void() free(VULKAN_HPP_NAMESPACE::DeviceMemory memory, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyBuffer(VULKAN_HPP_NAMESPACE::Buffer buffer, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL()=default
bool operator!() const VULKAN_HPP_NOEXCEPT
void getMultisamplePropertiesEXT(VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT *pMultisampleProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(DeferredOperationKHR const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion(VkSamplerYcbcrConversion samplerYcbcrConversion) VULKAN_HPP_NOEXCEPT
void setStencilReference(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setEvent(VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setScissorWithCount(uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D *pScissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR(uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroySamplerYcbcrConversionKHR(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Instance(VkInstance instance) VULKAN_HPP_NOEXCEPT
void drawIndexedIndirectCountKHR(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result bindImageMemory2(uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo *pBindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getExternalBufferProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VULKAN_HPP_NAMESPACE::ExternalBufferProperties *pExternalBufferProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getToolPropertiesEXT(uint32_t *pToolCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties *pToolProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
PhysicalDevice & operator=(VkPhysicalDevice physicalDevice) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector< StructureChain > getQueueFamilyProperties2KHR() const
void beginRenderingKHR(const VULKAN_HPP_NAMESPACE::RenderingInfo *pRenderingInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT(VkDebugReportCallbackEXT debugReportCallbackEXT) VULKAN_HPP_NOEXCEPT
void setLineWidth(float lineWidth, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR SwapchainKHR()=default
#define VULKAN_HPP_NAMESPACE
Definition: vulkan.hpp:229
void destroyPipelineCache(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void trimCommandPool(VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyDebugReportCallbackEXT(VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT Event(VkEvent event) VULKAN_HPP_NOEXCEPT
void setDiscardRectangleEXT(uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VULKAN_HPP_NAMESPACE::Rect2D *pDiscardRectangles, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(ValidationCacheEXT const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch > >::type createDebugReportCallbackEXTUnique(const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void copyMicromapToMemoryEXT(const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthCompareOpEXT(VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(DebugReportCallbackEXT const &rhs) const VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkVoidFunction)(void)
Definition: vulkan_core.h:2918
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
bool operator!() const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
void getExternalFenceProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VULKAN_HPP_NAMESPACE::ExternalFenceProperties *pExternalFenceProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Buffer()=default
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
VULKAN_HPP_CONSTEXPR SurfaceKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
GLbitfield GLuint64 timeout
Definition: glcorearb.h:1599
DeviceAddress getBufferAddressEXT(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR PipelineCache()=default
Pipeline & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getSurfaceFormatsKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, uint32_t *pSurfaceFormatCount, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR *pSurfaceFormats, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(Framebuffer const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR(VkDisplayKHR displayKHR) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result mapMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::DeviceSize size, VULKAN_HPP_NAMESPACE::MemoryMapFlags flags, void **ppData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::Semaphore, Dispatch > >::type createSemaphoreUnique(const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
#define VULKAN_HPP_TYPESAFE_EXPLICIT
Definition: vulkan.hpp:179
OpticalFlowSessionNV & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void bindDescriptorBuffersEXT(uint32_t bufferCount, const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT *pBindingInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyImage2(const VULKAN_HPP_NAMESPACE::CopyImageInfo2 *pCopyImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setColorWriteMaskEXT(uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ColorComponentFlags *pColorWriteMasks, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyPipelineLayout(VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
#define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
Definition: vulkan.hpp:5885
bool operator<(CuModuleNVX const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< UniqueHandle< VULKAN_HPP_NAMESPACE::Pipeline, Dispatch > > createRayTracingPipelineKHRUnique(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
DescriptorSetLayout & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void insertDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::RenderPass, Dispatch > >::type createRenderPass2Unique(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
bool operator==(PerformanceConfigurationINTEL const &rhs) const VULKAN_HPP_NOEXCEPT
void setFragmentShadingRateKHR(const VULKAN_HPP_NAMESPACE::Extent2D *pFragmentSize, const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Pipeline()=default
void destroyDescriptorSetLayout(VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
void setLineStippleEXT(uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(Instance const &rhs) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result signalSemaphore(const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo *pSignalInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createImageView(const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::ImageView *pView, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(SamplerYcbcrConversion const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createGraphicsPipelines(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo *pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Pipeline *pPipelines, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR PipelineLayout(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result displayPowerControlEXT(VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT *pDisplayPowerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< DataType > getQueryPoolResult(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getFaultInfoEXT(VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT *pFaultCounts, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT *pFaultInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< VULKAN_HPP_NAMESPACE::SwapchainKHR >::type createSharedSwapchainKHR(const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
GLint GLint GLsizei GLint GLenum format
Definition: glcorearb.h:108
VULKAN_HPP_NODISCARD Result createDescriptorSetLayout(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::DescriptorSetLayout *pSetLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(Device const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR RenderPass()=default
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch > >::type createDescriptorUpdateTemplateKHRUnique(const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV(VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(QueryPool const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR ShaderModule()=default
ResultValueType< void >::type reset(VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_TYPESAFE_EXPLICIT ImageView(VkImageView imageView) VULKAN_HPP_NOEXCEPT
bool operator==(Pipeline const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch >, SwapchainKHRAllocator > >::type createSharedSwapchainsKHRUnique(VULKAN_HPP_NAMESPACE::ArrayProxy< const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR > const &createInfos, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
CommandBuffer & operator=(VkCommandBuffer commandBuffer) VULKAN_HPP_NOEXCEPT
uint32_t getDeferredOperationMaxConcurrencyKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
GLint GLenum GLboolean GLsizei stride
Definition: glcorearb.h:872
VULKAN_HPP_NODISCARD ResultValue< UniqueHandle< VULKAN_HPP_NAMESPACE::Pipeline, Dispatch > > createComputePipelineUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_CONSTEXPR ImageView()=default
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV, Dispatch > >::type createOpticalFlowSessionNVUnique(const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void freeMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setViewportWithCountEXT(uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::Viewport *pViewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getAccelerationStructureCompatibilityKHR(const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR *pVersionInfo, VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR *pCompatibility, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
const GLuint * buffers
Definition: glcorearb.h:661
GLsizei const GLenum * attachments
Definition: glcorearb.h:2518
bool operator<(PrivateDataSlot const &rhs) const VULKAN_HPP_NOEXCEPT
uint32_t getImageViewHandleNVX(const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR AccelerationStructureNV()=default
bool operator<(PhysicalDevice const &rhs) const VULKAN_HPP_NOEXCEPT
bool operator!=(PipelineCache const &rhs) const VULKAN_HPP_NOEXCEPT
void executeCommands(uint32_t commandBufferCount, const VULKAN_HPP_NAMESPACE::CommandBuffer *pCommandBuffers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR SurfaceKHR()=default
void setRasterizationStreamEXT(uint32_t rasterizationStream, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void resetQueryPool(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::Fence, Dispatch > >::type registerEventEXTUnique(const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT &deviceEventInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV(uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV *pBindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
void setDepthBoundsTestEnable(VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< VULKAN_HPP_NAMESPACE::Pipeline > createRayTracingPipelineNV(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
bool operator!=(CommandPool const &rhs) const VULKAN_HPP_NOEXCEPT
bool operator==(PipelineLayout const &rhs) const VULKAN_HPP_NOEXCEPT
void getBufferMemoryRequirements2(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 *pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result importSemaphoreFdKHR(const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
DeviceAddress getAccelerationStructureAddressKHR(const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(CommandPool const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result waitSemaphoresKHR(const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo *pWaitInfo, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type end(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT(VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, size_t *pDataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createAccelerationStructureNV(const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::AccelerationStructureNV *pAccelerationStructure, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void resolveImage2KHR(const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 *pResolveImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void writeTimestamp2KHR(VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(DescriptorSet const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT()=default
*get result *(waiting if necessary)*A common idiom is to fire a bunch of sub tasks at the queue
Definition: thread.h:623
bool operator==(CommandPool const &rhs) const VULKAN_HPP_NOEXCEPT
GLint location
Definition: glcorearb.h:805
void drawIndirectCountKHR(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
DeviceMemory & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void endRendering(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
void updateBuffer(VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::DeviceSize dataSize, const void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyPrivateDataSlot(VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void submitDebugUtilsMessageEXT(VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT *pCallbackData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
VULKAN_HPP_NODISCARD ResultValue< VULKAN_HPP_NAMESPACE::Pipeline > createGraphicsPipeline(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getDescriptorEXT(const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void resetQueryPoolEXT(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getFramebufferTilePropertiesQCOM(VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, uint32_t *pPropertiesCount, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setRayTracingPipelineStackSizeKHR(uint32_t pipelineStackSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch > >::type createPrivateDataSlotEXTUnique(const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR(uint32_t *pFragmentShadingRateCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< VULKAN_HPP_NAMESPACE::Pipeline > createRayTracingPipelineKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void copyImageToBuffer2(const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 *pCopyImageToBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void nextSubpass(VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type waitIdle(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void waitEvents2(uint32_t eventCount, const VULKAN_HPP_NAMESPACE::Event *pEvents, const VULKAN_HPP_NAMESPACE::DependencyInfo *pDependencyInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getShaderInfoAMD(VULKAN_HPP_NAMESPACE::Pipeline pipeline, VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getExternalSemaphoreProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *pExternalSemaphoreProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
bool operator<(ImageView const &rhs) const VULKAN_HPP_NOEXCEPT
void drawIndirectCountAMD(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createHeadlessSurfaceEXT(const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR *pSurface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setStencilOpEXT(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, VULKAN_HPP_NAMESPACE::StencilOp failOp, VULKAN_HPP_NAMESPACE::StencilOp passOp, VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, VULKAN_HPP_NAMESPACE::CompareOp compareOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL(VkPerformanceConfigurationINTEL performanceConfigurationINTEL) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT Image(VkImage image) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createRenderPass(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::RenderPass *pRenderPass, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
#define VULKAN_HPP_NODISCARD
Definition: vulkan.hpp:224
bool operator!() const VULKAN_HPP_NOEXCEPT
GLuint const GLchar * name
Definition: glcorearb.h:786
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type release(VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void debugMarkerBeginEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT *pMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(PrivateDataSlot const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX(VkCuModuleNVX cuModuleNVX) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::pair< uint64_t, uint64_t > >::type getCalibratedTimestampEXT(const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT &timestampInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getAccelerationStructureOpaqueCaptureDescriptorDataEXT(const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(OpticalFlowSessionNV const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool(VkCommandPool commandPool) VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< UniqueHandle< VULKAN_HPP_NAMESPACE::Pipeline, Dispatch > > createRayTracingPipelineNVUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_CONSTEXPR Semaphore(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch > >::type createDescriptorPoolUnique(const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result mergePipelineCaches(VULKAN_HPP_NAMESPACE::PipelineCache dstCache, uint32_t srcCacheCount, const VULKAN_HPP_NAMESPACE::PipelineCache *pSrcCaches, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyOpticalFlowSessionNV(VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getFormatProperties2KHR(VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties2 *pFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(ShaderModule const &rhs) const VULKAN_HPP_NOEXCEPT
void setFrontFaceEXT(VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(DescriptorSetLayout const &rhs) const VULKAN_HPP_NOEXCEPT
ResultValueType< void >::type resetEvent(VULKAN_HPP_NAMESPACE::Event event, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
bool operator<(AccelerationStructureNV const &rhs) const VULKAN_HPP_NOEXCEPT
void bindInvocationMaskHUAWEI(VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
DescriptorUpdateTemplate & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR(VkSurfaceKHR surfaceKHR) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges(uint32_t memoryRangeCount, const VULKAN_HPP_NAMESPACE::MappedMemoryRange *pMemoryRanges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(PipelineCache const &rhs) const VULKAN_HPP_NOEXCEPT
ValidationCacheEXT & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch > >::type createAccelerationStructureNVUnique(const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void beginRenderPass2KHR(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo *pRenderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *pSubpassBeginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Pipeline(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Framebuffer()=default
bool operator==(Image const &rhs) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
bool operator!() const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch > >::type createFramebufferUnique(const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
bool operator!() const VULKAN_HPP_NOEXCEPT
void resolveImage(VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::ImageResolve *pRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroySamplerYcbcrConversion(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
IndirectCommandsLayoutNV & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
CuModuleNVX & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result allocateCommandBuffers(const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo *pAllocateInfo, VULKAN_HPP_NAMESPACE::CommandBuffer *pCommandBuffers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void pipelineBarrier2(const VULKAN_HPP_NAMESPACE::DependencyInfo *pDependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Sampler()=default
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::ExtensionProperties *pProperties, Dispatch const &d) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createPipelineCache(const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::PipelineCache *pPipelineCache, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
MicromapEXT & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNV(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV) VULKAN_HPP_NOEXCEPT
GLsizei samples
Definition: glcorearb.h:1298
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT()=default
void preprocessGeneratedCommandsNV(const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV *pGeneratedCommandsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR PhysicalDevice()=default
void destroy(const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR PipelineLayout()=default
void destroyImageView(VULKAN_HPP_NAMESPACE::ImageView imageView, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(CommandBuffer const &rhs) const VULKAN_HPP_NOEXCEPT
GLenum mode
Definition: glcorearb.h:99
bool operator!() const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
SurfaceKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
GLint GLint GLsizei GLsizei GLsizei depth
Definition: glcorearb.h:476
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch >, CommandBufferAllocator > >::type allocateCommandBuffersUnique(const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo &allocateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
DescriptorSet & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void executeGeneratedCommandsNV(VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV *pGeneratedCommandsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyImage2KHR(const VULKAN_HPP_NAMESPACE::CopyImageInfo2 *pCopyImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(OpticalFlowSessionNV const &rhs) const VULKAN_HPP_NOEXCEPT
bool operator!=(IndirectCommandsLayoutNV const &rhs) const VULKAN_HPP_NOEXCEPT
void getBufferMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements *pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT *pTagInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR *pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Pipeline *pPipelines, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
VULKAN_HPP_NODISCARD Result getSemaphoreCounterValue(VULKAN_HPP_NAMESPACE::Semaphore semaphore, uint64_t *pValue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDeviceMaskKHR(uint32_t deviceMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch > >::type acquirePerformanceConfigurationINTELUnique(const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL &acquireInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void setExtraPrimitiveOverestimationSizeEXT(float extraPrimitiveOverestimationSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthWriteEnable(VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyBufferToImage2KHR(const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 *pCopyBufferToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result presentKHR(const VULKAN_HPP_NAMESPACE::PresentInfoKHR *pPresentInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setStencilOp(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, VULKAN_HPP_NAMESPACE::StencilOp failOp, VULKAN_HPP_NAMESPACE::StencilOp passOp, VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, VULKAN_HPP_NAMESPACE::CompareOp compareOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
ShaderModule & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool(VkDescriptorPool descriptorPool) VULKAN_HPP_NOEXCEPT
bool operator<(ValidationCacheEXT const &rhs) const VULKAN_HPP_NOEXCEPT
void endRenderingKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createQueryPool(const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::QueryPool *pQueryPool, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::Fence, Dispatch > >::type createFenceUnique(const VULKAN_HPP_NAMESPACE::FenceCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void traceRaysKHR(const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR CuModuleNVX(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void setDepthClampEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyMemoryToMicromapEXT(const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
CommandPool & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT(VkValidationCacheEXT validationCacheEXT) VULKAN_HPP_NOEXCEPT
void beginQuery(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, VULKAN_HPP_NAMESPACE::QueryControlFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void buildAccelerationStructuresIndirectKHR(uint32_t infoCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *pInfos, const VULKAN_HPP_NAMESPACE::DeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t *const *ppMaxPrimitiveCounts, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain< X, Y, Z...> getFeatures2KHR() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getSwapchainImagesKHR(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VULKAN_HPP_NAMESPACE::Image *pSwapchainImages, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
void setStencilTestEnable(VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
QueryPool & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR(VULKAN_HPP_NAMESPACE::Semaphore semaphore, uint64_t *pValue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(AccelerationStructureKHR const &rhs) const VULKAN_HPP_NOEXCEPT
void setCoverageToColorEnableNV(VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::ExtensionProperties *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type writeAccelerationStructuresPropertyKHR(VULKAN_HPP_NAMESPACE::ArrayProxy< const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR > const &accelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties(uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::LayerProperties *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Image()=default
VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR(VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindShadingRateImageNV(VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
VULKAN_HPP_NODISCARD Result getPipelineExecutableInternalRepresentationsKHR(const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR *pInternalRepresentations, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
GLsizeiptr size
Definition: glcorearb.h:664
VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR(VkDeferredOperationKHR deferredOperationKHR) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate(VkDescriptorUpdateTemplate descriptorUpdateTemplate) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT BufferView(VkBufferView bufferView) VULKAN_HPP_NOEXCEPT
bool operator!=(Instance const &rhs) const VULKAN_HPP_NOEXCEPT
void beginRendering(const VULKAN_HPP_NAMESPACE::RenderingInfo *pRenderingInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void fillBuffer(VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::DeviceSize size, uint32_t data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createBufferView(const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::BufferView *pView, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
GLenum GLenum dst
Definition: glcorearb.h:1793
void setDepthWriteEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result bindBufferMemory2KHR(uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo *pBindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
void getMicromapCompatibilityEXT(const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT *pVersionInfo, VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR *pCompatibility, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
GLuint shader
Definition: glcorearb.h:785
VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR(VkDisplayModeKHR displayModeKHR) VULKAN_HPP_NOEXCEPT
bool operator<(Queue const &rhs) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
bool operator!=(AccelerationStructureNV const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createImage(const VULKAN_HPP_NAMESPACE::ImageCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Image *pImage, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
GLsizeiptr const void GLenum usage
Definition: glcorearb.h:664
void setCoarseSampleOrderNV(VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV *pCustomSampleOrders, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR(VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindImageMemory(VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void setCoverageToColorLocationNV(uint32_t coverageToColorLocation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR(uint32_t swapchainCount, const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR *pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::SwapchainKHR *pSwapchains, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result acquireProfilingLockKHR(const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
bool operator!=(std::string const &lhs, ArrayWrapper1D< char, N > const &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:360
Usd_Term operator!(Usd_PrimFlags flag)
Definition: primFlags.h:131
void writeBufferMarkerAMD(VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, uint32_t marker, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR MicromapEXT()=default
VULKAN_HPP_NODISCARD Result getOpticalFlowImageFormatsNV(const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV *pImageFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthBias(float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyRenderPass(VULKAN_HPP_NAMESPACE::RenderPass renderPass, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR(const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR *pSurface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void pipelineBarrier2KHR(const VULKAN_HPP_NAMESPACE::DependencyInfo *pDependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindOpticalFlowSessionImageNV(VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint, VULKAN_HPP_NAMESPACE::ImageView view, VULKAN_HPP_NAMESPACE::ImageLayout layout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_CONSTEXPR BufferView(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR(uint32_t *pPhysicalDeviceGroupCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setFrontFace(VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyImageToBuffer(VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::BufferImageCopy *pRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Instance(std::nullptr_t) VULKAN_HPP_NOEXCEPT
bool operator!=(SwapchainKHR const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL(const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL *pInitializeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR *pModes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
GLenum GLsizei GLsizei GLint * values
Definition: glcorearb.h:1602
VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore(VkSemaphore semaphore) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::MicromapEXT, Dispatch > >::type createMicromapEXTUnique(const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
bool operator<(CuFunctionNVX const &rhs) const VULKAN_HPP_NOEXCEPT
GLuint color
Definition: glcorearb.h:1261
void copyAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type releasePerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain< X, Y, Z...> getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT
bool operator==(DisplayKHR const &rhs) const VULKAN_HPP_NOEXCEPT
void bindPipeline(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createSemaphore(const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Semaphore *pSemaphore, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void resetDescriptorPool(VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
bool operator!=(Buffer const &rhs) const VULKAN_HPP_NOEXCEPT
void copyBuffer2KHR(const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 *pCopyBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Event(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getSamplerOpaqueCaptureDescriptorDataEXT(const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(DeviceMemory const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint32_t *pPresentationTimingCount, VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE *pPresentationTimings, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createFence(const VULKAN_HPP_NAMESPACE::FenceCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Fence *pFence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain< X, Y, Z...> getProperties2() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch > >::type createDisplayModeKHRUnique(VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
bool operator!() const VULKAN_HPP_NOEXCEPT
void setSampleLocationsEXT(const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT *pSampleLocationsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setScissor(uint32_t firstScissor, uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D *pScissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void freeCommandBuffers(VULKAN_HPP_NAMESPACE::CommandPool commandPool, uint32_t commandBufferCount, const VULKAN_HPP_NAMESPACE::CommandBuffer *pCommandBuffers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setSampleMaskEXT(VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, const VULKAN_HPP_NAMESPACE::SampleMask *pSampleMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getImageMemoryRequirements(VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::MemoryRequirements *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void nextSubpass2KHR(const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *pSubpassBeginInfo, const VULKAN_HPP_NAMESPACE::SubpassEndInfo *pSubpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
VULKAN_HPP_CONSTEXPR Framebuffer(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void clearAttachments(uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ClearAttachment *pAttachments, uint32_t rectCount, const VULKAN_HPP_NAMESPACE::ClearRect *pRects, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyCuFunctionNVX(VULKAN_HPP_NAMESPACE::CuFunctionNVX function, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getQueue2(const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 *pQueueInfo, VULKAN_HPP_NAMESPACE::Queue *pQueue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(PhysicalDevice const &rhs) const VULKAN_HPP_NOEXCEPT
void destroyFence(VULKAN_HPP_NAMESPACE::Fence fence, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
LeafData & operator=(const LeafData &)=delete
#define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
Definition: vulkan.hpp:5886
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result createInstance(const VULKAN_HPP_NAMESPACE::InstanceCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Instance *pInstance, Dispatch const &d) VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
void trimCommandPoolKHR(VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
#define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
Definition: vulkan.hpp:5884
GLuint index
Definition: glcorearb.h:786
bool operator==(std::string const &lhs, ArrayWrapper1D< char, N > const &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:354
void destroyValidationCacheEXT(VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setConservativeRasterizationModeEXT(VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *pAccelerationStructure, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector< StructureChain > getQueueFamilyProperties2() const
Sampler & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result waitForFences(uint32_t fenceCount, const VULKAN_HPP_NAMESPACE::Fence *pFences, VULKAN_HPP_NAMESPACE::Bool32 waitAll, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void decompressMemoryIndirectCountNV(VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsAddress, VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result registerDisplayEventEXT(VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT *pDisplayEventInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Fence *pFence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getSupportedFramebufferMixedSamplesCombinationsNV(uint32_t *pCombinationCount, VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV *pCombinations, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type compileDeferredNV(VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getSwapchainStatusKHR(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void setColorWriteEnableEXT(uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::Bool32 *pColorWriteEnables, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR AccelerationStructureKHR()=default
bool operator==(Buffer const &rhs) const VULKAN_HPP_NOEXCEPT
void setCoverageModulationTableEnableNV(VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
void copyMicromapEXT(const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV(uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain< X, Y, Z...> getMemoryProperties2() const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV(VkAccelerationStructureNV accelerationStructureNV) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createComputePipelines(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo *pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Pipeline *pPipelines, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getExternalFencePropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VULKAN_HPP_NAMESPACE::ExternalFenceProperties *pExternalFenceProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT *pTagInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(DescriptorPool const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL(const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL *pMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createRenderPass2(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::RenderPass *pRenderPass, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::Device, Dispatch > >::type createDeviceUnique(const VULKAN_HPP_NAMESPACE::DeviceCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getSparseImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyImage(VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR PhysicalDevice(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void setColorBlendEquationEXT(uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT *pColorBlendEquations, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result writeAccelerationStructuresPropertiesKHR(uint32_t accelerationStructureCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *pAccelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t dataSize, void *pData, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
void getImageSparseMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *pSparseMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(DeferredOperationKHR const &rhs) const VULKAN_HPP_NOEXCEPT
void drawMeshTasksIndirectNV(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
void destroySurfaceKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
ResultValueType< void >::type resetCommandPool(VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getMemoryRemoteAddressNV(const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV *pMemoryGetRemoteAddressInfo, VULKAN_HPP_NAMESPACE::RemoteAddressNV *pAddress, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getDescriptorSetLayoutSizeEXT(VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, VULKAN_HPP_NAMESPACE::DeviceSize *pLayoutSizeInBytes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
DeviceSize getRayTracingShaderGroupStackSizeKHR(VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV()=default
void drawIndexedIndirect(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT(VULKAN_HPP_NAMESPACE::SurfaceKHR surface, VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT *pSurfaceCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate(const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *pDescriptorUpdateTemplate, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
PipelineCache & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Device & operator=(VkDevice device) VULKAN_HPP_NOEXCEPT
#define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE
Definition: vulkan.hpp:5875
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch > >::type createSwapchainKHRUnique(const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createCuFunctionNVX(const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::CuFunctionNVX *pFunction, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void clearDepthStencilImage(VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VULKAN_HPP_NAMESPACE::ImageSubresourceRange *pRanges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(Sampler const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< VULKAN_HPP_NAMESPACE::Pipeline, Dispatch >, PipelineAllocator > > createRayTracingPipelinesKHRUnique(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy< const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR > const &createInfos, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createCommandPool(const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::CommandPool *pCommandPool, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
void setCullModeEXT(VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyDescriptorUpdateTemplate(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getSurfaceFormats2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR *pSurfaceFormats, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT(VkMicromapEXT micromapEXT) VULKAN_HPP_NOEXCEPT
void setDepthBiasEnable(VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getQueryPoolResults(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
GLint GLsizei width
Definition: glcorearb.h:103
VULKAN_HPP_CONSTEXPR CommandBuffer()=default
bool operator==(ValidationCacheEXT const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createOpticalFlowSessionNV(const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV *pSession, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyEvent(VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getSemaphoreFdKHR(const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(OpticalFlowSessionNV const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR DeferredOperationKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getImageViewAddressNVX(VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
Definition: core.h:982
bool operator<(Buffer const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getSurfaceSupportKHR(uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface, VULKAN_HPP_NAMESPACE::Bool32 *pSupported, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR DescriptorSetLayout()=default
void getProperties(VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
ResultValueType< void >::type acquireDrmDisplayEXT(int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void endDebugUtilsLabelEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyBuffer(VULKAN_HPP_NAMESPACE::Buffer srcBuffer, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::BufferCopy *pRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR ShaderModule(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void getDescriptorSetLayoutSupportKHR(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo *pCreateInfo, VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *pSupport, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getImageFormatProperties(VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, VULKAN_HPP_NAMESPACE::ImageFormatProperties *pImageFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void nextSubpass2(const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *pSubpassBeginInfo, const VULKAN_HPP_NAMESPACE::SubpassEndInfo *pSubpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void dispatchIndirect(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::RenderPass, Dispatch > >::type createRenderPassUnique(const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createValidationCacheEXT(const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::ValidationCacheEXT *pValidationCache, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::ImageView, Dispatch > >::type createImageViewUnique(const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
bool operator<(Fence const &rhs) const VULKAN_HPP_NOEXCEPT
BufferView & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createEvent(const VULKAN_HPP_NAMESPACE::EventCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Event *pEvent, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawMeshTasksIndirectCountNV(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
void setShadingRateImageEnableNV(VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
void setDeviceMask(uint32_t deviceMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(DisplayKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Device & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void copyImageToBuffer2KHR(const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 *pCopyImageToBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch > >::type createCuModuleNVXUnique(const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
DebugReportCallbackEXT & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: core.h:1131
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
VULKAN_HPP_NODISCARD Result getDisplayProperties2KHR(uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayProperties2KHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyIndirectCommandsLayoutNV(VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endQueryIndexedEXT(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getImageSparseMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *pSparseMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(DisplayModeKHR const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV(VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType, VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV *pExternalImageFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR(VULKAN_HPP_NAMESPACE::DisplayKHR display, uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDescriptorBufferOffsetsEXT(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t *pBufferIndices, const VULKAN_HPP_NAMESPACE::DeviceSize *pOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR CommandPool()=default
bool operator==(DescriptorPool const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR CuModuleNVX()=default
bool operator==(CuModuleNVX const &rhs) const VULKAN_HPP_NOEXCEPT
void copyMemoryToAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawIndexedIndirectCountAMD(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT OpticalFlowSessionNV(VkOpticalFlowSessionNV opticalFlowSessionNV) VULKAN_HPP_NOEXCEPT
void setLogicOpEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
DescriptorPool & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *pImageFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setRepresentativeFragmentTestEnableNV(VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
bool operator==(CuFunctionNVX const &rhs) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
void getImageMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements *pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindVertexBuffers2(uint32_t firstBinding, uint32_t bindingCount, const VULKAN_HPP_NAMESPACE::Buffer *pBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize *pOffsets, const VULKAN_HPP_NAMESPACE::DeviceSize *pSizes, const VULKAN_HPP_NAMESPACE::DeviceSize *pStrides, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch > >::type createShaderModuleUnique(const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void setLineRasterizationModeEXT(VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setBlendConstants(const float blendConstants[4], Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getCheckpointData2NV(uint32_t *pCheckpointDataCount, VULKAN_HPP_NAMESPACE::CheckpointData2NV *pCheckpointData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch > >::type createValidationCacheEXTUnique(const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
Semaphore & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
void setStencilWriteMask(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR AccelerationStructureNV(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result bindImageMemory2KHR(uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo *pBindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getImageSparseMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *pSparseMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthTestEnable(VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT) VULKAN_HPP_NOEXCEPT
ResultValueType< void >::type setPrivateDataEXT(VULKAN_HPP_NAMESPACE::ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_CONSTEXPR CommandPool(std::nullptr_t) VULKAN_HPP_NOEXCEPT
that also have some descendant prim *whose name begins with which in turn has a child named baz where *the predicate and *a name There is also one special expression reference
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
bool operator==(AccelerationStructureKHR const &rhs) const VULKAN_HPP_NOEXCEPT
DisplayModeKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void setTessellationDomainOriginEXT(VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(DeferredOperationKHR const &rhs) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getDrmDisplayEXT(int32_t drmFd, uint32_t connectorId, VULKAN_HPP_NAMESPACE::DisplayKHR *display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::Event, Dispatch > >::type createEventUnique(const VULKAN_HPP_NAMESPACE::EventCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::Image, Dispatch > >::type createImageUnique(const VULKAN_HPP_NAMESPACE::ImageCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
bool operator!() const VULKAN_HPP_NOEXCEPT
void setAlphaToCoverageEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache(VkPipelineCache pipelineCache) VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
void getAccelerationStructureBuildSizesKHR(VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR *pSizeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
type
Definition: core.h:1059
void beginRenderPass(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo *pRenderPassBegin, VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawIndirectByteCountEXT(uint32_t instanceCount, uint32_t firstInstance, VULKAN_HPP_NAMESPACE::Buffer counterBuffer, VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result enumerateQueueFamilyPerformanceQueryCountersKHR(uint32_t queueFamilyIndex, uint32_t *pCounterCount, VULKAN_HPP_NAMESPACE::PerformanceCounterKHR *pCounters, VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR *pCounterDescriptions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch > >::type createPipelineLayoutUnique(const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result allocateMemory(const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo *pAllocateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::DeviceMemory *pMemory, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< VULKAN_HPP_NAMESPACE::Pipeline, Dispatch >, PipelineAllocator > > createRayTracingPipelinesNVUnique(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy< const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV > const &createInfos, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
bool operator==(SwapchainKHR const &rhs) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
PipelineLayout & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void debugReportMessageEXT(VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
VULKAN_HPP_NODISCARD Result createShaderModule(const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::ShaderModule *pShaderModule, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setCullMode(VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch > >::type createHeadlessSurfaceEXTUnique(const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void setCheckpointNV(const void *pCheckpointMarker, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
PFN_vkVoidFunction getProcAddr(const char *pName, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(Pipeline const &rhs) const VULKAN_HPP_NOEXCEPT
bool operator<(DeviceMemory const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result signalSemaphoreKHR(const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo *pSignalInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Semaphore()=default
void traceRaysIndirectKHR(const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT *pNameInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR PrivateDataSlot(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void buildMicromapsEXT(uint32_t infoCount, const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT *pInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void insertDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
void uninitializePerformanceApiINTEL(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, uint32_t infoCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *pInfos, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(Image const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< VULKAN_HPP_NAMESPACE::Pipeline > createComputePipeline(VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
Instance & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void copyMemoryToImageIndirectNV(VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers *pImageSubresources, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getQueueFamilyProperties(uint32_t *pQueueFamilyPropertyCount, VULKAN_HPP_NAMESPACE::QueueFamilyProperties *pQueueFamilyProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR SwapchainKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result submit2KHR(uint32_t submitCount, const VULKAN_HPP_NAMESPACE::SubmitInfo2 *pSubmits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
PhysicalDevice & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
uint64_t getBufferOpaqueCaptureAddress(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getRayTracingCaptureReplayShaderGroupHandlesKHR(VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
VULKAN_HPP_CONSTEXPR DeferredOperationKHR()=default
VULKAN_HPP_CONSTEXPR Fence()=default
bool operator<(Sampler const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Queue(std::nullptr_t) VULKAN_HPP_NOEXCEPT
GLuint64 GLenum GLint fd
Definition: RE_OGL.h:262
void writeTimestamp2(VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type setPerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
RenderPass & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
void destroyAccelerationStructureNV(VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
CommandBuffer(VkCommandBuffer commandBuffer) VULKAN_HPP_NOEXCEPT
CommandBuffer & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
void destroyDebugUtilsMessengerEXT(VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(ImageView const &rhs) const VULKAN_HPP_NOEXCEPT
CuFunctionNVX & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Result freeDescriptorSets(VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, uint32_t descriptorSetCount, const VULKAN_HPP_NAMESPACE::DescriptorSet *pDescriptorSets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindPipelineShaderGroupNV(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t groupIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createDeferredOperationKHR(const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::DeferredOperationKHR *pDeferredOperation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout(VkPipelineLayout pipelineLayout) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result bindBufferMemory2(uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo *pBindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type writeMicromapsPropertyEXT(VULKAN_HPP_NAMESPACE::ArrayProxy< const VULKAN_HPP_NAMESPACE::MicromapEXT > const &micromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void pushDescriptorSetWithTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, const void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Definition: format.h:895
void endQuery(VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getFenceFdKHR(const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR *pGetFdInfo, int *pFd, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setSampleLocationsEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void waitEvents(uint32_t eventCount, const VULKAN_HPP_NAMESPACE::Event *pEvents, VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VULKAN_HPP_NAMESPACE::MemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *pImageMemoryBarriers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setViewportWithCount(uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::Viewport *pViewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(Framebuffer const &rhs) const VULKAN_HPP_NOEXCEPT
void drawIndirectCount(VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setScissorWithCountEXT(uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D *pScissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void resetEvent2(VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(IndirectCommandsLayoutNV const &rhs) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
void copyImage(VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::ImageCopy *pRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(SurfaceKHR const &rhs) const VULKAN_HPP_NOEXCEPT
GLsizei const GLuint const GLintptr const GLsizei * strides
Definition: glcorearb.h:2625
VULKAN_HPP_CONSTEXPR Event()=default
bool operator!=(DescriptorSet const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createPrivateDataSlotEXT(const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::PrivateDataSlot *pPrivateDataSlot, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setPatchControlPointsEXT(uint32_t patchControlPoints, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
void releaseProfilingLockKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties(uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::LayerProperties *pProperties, Dispatch const &d) VULKAN_HPP_NOEXCEPT
uint64_t getMemoryOpaqueCaptureAddress(const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Device(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR CommandBuffer(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::Instance, Dispatch > >::type createInstanceUnique(const VULKAN_HPP_NAMESPACE::InstanceCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator, Dispatch const &d)
VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass(VkRenderPass renderPass) VULKAN_HPP_NOEXCEPT
void destroySwapchainKHR(VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
PerformanceConfigurationINTEL & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< VULKAN_HPP_NAMESPACE::CommandPool, Dispatch > >::type createCommandPoolUnique(const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo &createInfo, Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyMicromapEXT(VULKAN_HPP_NAMESPACE::MicromapEXT micromap, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getFeatures(VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures *pFeatures, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glcorearb.h:1297
GLenum src
Definition: glcorearb.h:1793
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
void setDepthClipNegativeOneToOneEXT(VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(PipelineCache const &rhs) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR PrivateDataSlot()=default
void setEvent2(VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo *pDependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT *pNameInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(SamplerYcbcrConversion const &rhs) const VULKAN_HPP_NOEXCEPT