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_HPP
9	#define VULKAN_HPP
10
11	#if defined( _MSVC_LANG )
12	# define VULKAN_HPP_CPLUSPLUS _MSVC_LANG
13	#else
14	# define VULKAN_HPP_CPLUSPLUS __cplusplus
15	#endif
16
17	#if 201703L < VULKAN_HPP_CPLUSPLUS
18	# define VULKAN_HPP_CPP_VERSION 20
19	#elif 201402L < VULKAN_HPP_CPLUSPLUS
20	# define VULKAN_HPP_CPP_VERSION 17
21	#elif 201103L < VULKAN_HPP_CPLUSPLUS
22	# define VULKAN_HPP_CPP_VERSION 14
23	#elif 199711L < VULKAN_HPP_CPLUSPLUS
24	# define VULKAN_HPP_CPP_VERSION 11
25	#else
26	# error "vulkan.hpp needs at least c++ standard version 11"
27	#endif
28
29	#include <algorithm>
30	#include <array> // ArrayWrapperND
31	#include <string> // std::string
32	#include <vulkan/vulkan.h>
33	#if 17 <= VULKAN_HPP_CPP_VERSION
34	# include <string_view> // std::string_view
35	#endif
36
37	#if defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
38	# if !defined( VULKAN_HPP_NO_SMART_HANDLE )
39	# define VULKAN_HPP_NO_SMART_HANDLE
40	# endif
41	#else
42	# include <tuple> // std::tie
43	# include <vector> // std::vector
44	#endif
45
46	#if !defined( VULKAN_HPP_NO_EXCEPTIONS )
47	# include <system_error> // std::is_error_code_enum
48	#endif
49
50	#if defined( VULKAN_HPP_NO_CONSTRUCTORS )
51	# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
52	# define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS
53	# endif
54	# if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
55	# define VULKAN_HPP_NO_UNION_CONSTRUCTORS
56	# endif
57	#endif
58
59	#if defined( VULKAN_HPP_NO_SETTERS )
60	# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
61	# define VULKAN_HPP_NO_STRUCT_SETTERS
62	# endif
63	# if !defined( VULKAN_HPP_NO_UNION_SETTERS )
64	# define VULKAN_HPP_NO_UNION_SETTERS
65	# endif
66	#endif
67
68	#if !defined( VULKAN_HPP_ASSERT )
69	# include <cassert>
70	# define VULKAN_HPP_ASSERT assert
71	#endif
72
73	#if !defined( VULKAN_HPP_ASSERT_ON_RESULT )
74	# define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT
75	#endif
76
77	#if !defined( VULKAN_HPP_STATIC_ASSERT )
78	# define VULKAN_HPP_STATIC_ASSERT static_assert
79	#endif
80
81	#if !defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL )
82	# define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1
83	#endif
84
85	#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1
86	# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined(__Fuchsia__)
87	# include <dlfcn.h>
88	# elif defined( _WIN32 )
89	typedef struct HINSTANCE__ * HINSTANCE;
90	# if defined( _WIN64 )
91	typedef int64_t( __stdcall * FARPROC )();
92	# else
93	typedef int( __stdcall * FARPROC )();
94	# endif
95	extern "C" __declspec( dllimport ) HINSTANCE __stdcall LoadLibraryA( char const * lpLibFileName );
96	extern "C" __declspec( dllimport ) int __stdcall FreeLibrary( HINSTANCE hLibModule );
97	extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE hModule, const char * lpProcName );
98	# endif
99	#endif
100
101	#if !defined( __has_include )
102	# define __has_include( x ) false
103	#endif
104
105	#if ( 201907 <= __cpp_lib_three_way_comparison ) && __has_include( <compare> ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR )
106	# define VULKAN_HPP_HAS_SPACESHIP_OPERATOR
107	#endif
108	#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
109	# include <compare>
110	#endif
111
112	#if ( 201803 <= __cpp_lib_span )
113	# define VULKAN_HPP_SUPPORT_SPAN
114	# include <span>
115	#endif
116
117
118	static_assert( VK_HEADER_VERSION == 238, "Wrong VK_HEADER_VERSION!" );
119
120	// 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
121	// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
122	#if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
123	# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
124	# define VULKAN_HPP_TYPESAFE_CONVERSION
125	# endif
126	#endif
127
128	// <tuple> includes <sys/sysmacros.h> through some other header
129	// this results in major(x) being resolved to gnu_dev_major(x)
130	// which is an expression in a constructor initializer list.
131	#if defined( major )
132	# undef major
133	#endif
134	#if defined( minor )
135	# undef minor
136	#endif
137
138	// Windows defines MemoryBarrier which is deprecated and collides
139	// with the VULKAN_HPP_NAMESPACE::MemoryBarrier struct.
140	#if defined( MemoryBarrier )
141	# undef MemoryBarrier
142	#endif
143
144	#if !defined( VULKAN_HPP_HAS_UNRESTRICTED_UNIONS )
145	# if defined( __clang__ )
146	# if __has_feature( cxx_unrestricted_unions )
147	# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
148	# endif
149	# elif defined( __GNUC__ )
150	# define GCC_VERSION ( __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ )
151	# if 40600 <= GCC_VERSION
152	# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
153	# endif
154	# elif defined( _MSC_VER )
155	# if 1900 <= _MSC_VER
156	# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
157	# endif
158	# endif
159	#endif
160
161	#if !defined( VULKAN_HPP_INLINE )
162	# if defined( __clang__ )
163	# if __has_attribute( always_inline )
164	# define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
165	# else
166	# define VULKAN_HPP_INLINE inline
167	# endif
168	# elif defined( __GNUC__ )
169	# define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
170	# elif defined( _MSC_VER )
171	# define VULKAN_HPP_INLINE inline
172	# else
173	# define VULKAN_HPP_INLINE inline
174	# endif
175	#endif
176
177	#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
178	# define VULKAN_HPP_TYPESAFE_EXPLICIT
179	#else
180	# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
181	#endif
182
183	#if defined( __cpp_constexpr )
184	# define VULKAN_HPP_CONSTEXPR constexpr
185	# if __cpp_constexpr >= 201304
186	# define VULKAN_HPP_CONSTEXPR_14 constexpr
187	# else
188	# define VULKAN_HPP_CONSTEXPR_14
189	# endif
190	# define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr
191	#else
192	# define VULKAN_HPP_CONSTEXPR
193	# define VULKAN_HPP_CONSTEXPR_14
194	# define VULKAN_HPP_CONST_OR_CONSTEXPR const
195	#endif
196
197	#if !defined( VULKAN_HPP_NOEXCEPT )
198	# if defined( _MSC_VER ) && ( _MSC_VER <= 1800 )
199	# define VULKAN_HPP_NOEXCEPT
200	# else
201	# define VULKAN_HPP_NOEXCEPT noexcept
202	# define VULKAN_HPP_HAS_NOEXCEPT 1
203	# if defined( VULKAN_HPP_NO_EXCEPTIONS )
204	# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS noexcept
205	# else
206	# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
207	# endif
208	# endif
209	#endif
210
211	#if 14 <= VULKAN_HPP_CPP_VERSION
212	# define VULKAN_HPP_DEPRECATED( msg ) [[deprecated( msg )]]
213	#else
214	# define VULKAN_HPP_DEPRECATED( msg )
215	#endif
216
217	#if ( 17 <= VULKAN_HPP_CPP_VERSION ) && !defined( VULKAN_HPP_NO_NODISCARD_WARNINGS )
218	# define VULKAN_HPP_NODISCARD [[nodiscard]]
219	# if defined( VULKAN_HPP_NO_EXCEPTIONS )
220	# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS [[nodiscard]]
221	# else
222	# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
223	# endif
224	#else
225	# define VULKAN_HPP_NODISCARD
226	# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
227	#endif
228
229	#if !defined( VULKAN_HPP_NAMESPACE )
230	# define VULKAN_HPP_NAMESPACE vk
231	#endif
232
233	#define VULKAN_HPP_STRINGIFY2( text ) #text
234	#define VULKAN_HPP_STRINGIFY( text ) VULKAN_HPP_STRINGIFY2( text )
235	#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
236
237
238	namespace VULKAN_HPP_NAMESPACE
239	{
240	template <typename T, size_t N>
241	class ArrayWrapper1D : public std::array<T, N>
242	{
243	public:
244	VULKAN_HPP_CONSTEXPR ArrayWrapper1D() VULKAN_HPP_NOEXCEPT
245	: std::array<T, N>()
246	{}
247
248	VULKAN_HPP_CONSTEXPR ArrayWrapper1D( std::array<T, N> const & data ) VULKAN_HPP_NOEXCEPT
249	: std::array<T, N>( data )
250	{}
251
252	#if ( VK_USE_64_BIT_PTR_DEFINES == 0 )
253	// on 32 bit compiles, needs overloads on index type int to resolve ambiguities
254	VULKAN_HPP_CONSTEXPR T const & operator[]( int index ) const VULKAN_HPP_NOEXCEPT
255	{
256	return std::array<T, N>::operator[]( index );
257	}
258
259	T & operator[]( int index ) VULKAN_HPP_NOEXCEPT
260	{
261	return std::array<T, N>::operator[]( index );
262	}
263	#endif
264
265	operator T const * () const VULKAN_HPP_NOEXCEPT
266	{
267	return this->data();
268	}
269
270	operator T * () VULKAN_HPP_NOEXCEPT
271	{
272	return this->data();
273	}
274
275	template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
276	operator std::string() const
277	{
278	return std::string( this->data() );
279	}
280
281	#if 17 <= VULKAN_HPP_CPP_VERSION
282	template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
283	operator std::string_view() const
284	{
285	return std::string_view( this->data() );
286	}
287	#endif
288
289	#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
290	template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
291	std::strong_ordering operator<=>( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
292	{
293	return *static_cast<std::array<char, N> const *>( this ) <=> *static_cast<std::array<char, N> const *>( &rhs );
294	}
295	#else
296	template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
297	bool operator<( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
298	{
299	return *static_cast<std::array<char, N> const *>( this ) < *static_cast<std::array<char, N> const *>( &rhs );
300	}
301
302	template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
303	bool operator<=( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
304	{
305	return *static_cast<std::array<char, N> const *>( this ) <= *static_cast<std::array<char, N> const *>( &rhs );
306	}
307
308	template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
309	bool operator>( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
310	{
311	return *static_cast<std::array<char, N> const *>( this ) > *static_cast<std::array<char, N> const *>( &rhs );
312	}
313
314	template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
315	bool operator>=( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
316	{
317	return *static_cast<std::array<char, N> const *>( this ) >= *static_cast<std::array<char, N> const *>( &rhs );
318	}
319	#endif
320
321	template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
322	bool operator==( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
323	{
324	return *static_cast<std::array<char, N> const *>( this ) == *static_cast<std::array<char, N> const *>( &rhs );
325	}
326
327	template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
328	bool operator!=( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
329	{
330	return *static_cast<std::array<char, N> const *>( this ) != *static_cast<std::array<char, N> const *>( &rhs );
331	}
332	};
333
334	// specialization of relational operators between std::string and arrays of chars
335	template <size_t N>
336	bool operator<( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
337	{
338	return lhs < rhs.data();
339	}
340
341	template <size_t N>
342	bool operator<=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
343	{
344	return lhs <= rhs.data();
345	}
346
347	template <size_t N>
348	bool operator>( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
349	{
350	return lhs > rhs.data();
351	}
352
353	template <size_t N>
354	bool operator>=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
355	{
356	return lhs >= rhs.data();
357	}
358
359	template <size_t N>
360	bool operator==( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
361	{
362	return lhs == rhs.data();
363	}
364
365	template <size_t N>
366	bool operator!=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
367	{
368	return lhs != rhs.data();
369	}
370
371	template <typename T, size_t N, size_t M>
372	class ArrayWrapper2D : public std::array<ArrayWrapper1D<T, M>, N>
373	{
374	public:
375	VULKAN_HPP_CONSTEXPR ArrayWrapper2D() VULKAN_HPP_NOEXCEPT
376	: std::array<ArrayWrapper1D<T, M>, N>()
377	{}
378
379	VULKAN_HPP_CONSTEXPR ArrayWrapper2D( std::array<std::array<T, M>, N> const & data ) VULKAN_HPP_NOEXCEPT
380	: std::array<ArrayWrapper1D<T, M>, N>( *reinterpret_cast<std::array<ArrayWrapper1D<T, M>, N> const *>( &data ) )
381	{}
382	};
383
384	template <typename FlagBitsType>
385	struct FlagTraits
386	{
387	static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = false;
388	};
389
390	template <typename BitType>
391	class Flags
392	{
393	public:
394	using MaskType = typename std::underlying_type<BitType>::type;
395
396	// constructors
397	VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT
398	: m_mask( 0 )
399	{}
400
401	VULKAN_HPP_CONSTEXPR Flags( BitType bit ) VULKAN_HPP_NOEXCEPT
402	: m_mask( static_cast<MaskType>( bit ) )
403	{}
404
405	VULKAN_HPP_CONSTEXPR Flags( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
406
407	VULKAN_HPP_CONSTEXPR explicit Flags( MaskType flags ) VULKAN_HPP_NOEXCEPT
408	: m_mask( flags )
409	{}
410
411	// relational operators
412	#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
413	auto operator<=>( Flags<BitType> const & ) const = default;
414	#else
415	VULKAN_HPP_CONSTEXPR bool operator<( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
416	{
417	return m_mask < rhs.m_mask;
418	}
419
420	VULKAN_HPP_CONSTEXPR bool operator<=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
421	{
422	return m_mask <= rhs.m_mask;
423	}
424
425	VULKAN_HPP_CONSTEXPR bool operator>( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
426	{
427	return m_mask > rhs.m_mask;
428	}
429
430	VULKAN_HPP_CONSTEXPR bool operator>=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
431	{
432	return m_mask >= rhs.m_mask;
433	}
434
435	VULKAN_HPP_CONSTEXPR bool operator==( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
436	{
437	return m_mask == rhs.m_mask;
438	}
439
440	VULKAN_HPP_CONSTEXPR bool operator!=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
441	{
442	return m_mask != rhs.m_mask;
443	}
444	#endif
445
446	// logical operator
447	VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT
448	{
449	return !m_mask;
450	}
451
452	// bitwise operators
453	VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
454	{
455	return Flags<BitType>( m_mask & rhs.m_mask );
456	}
457
458	VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
459	{
460	return Flags<BitType>( m_mask | rhs.m_mask );
461	}
462
463	VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
464	{
465	return Flags<BitType>( m_mask ^ rhs.m_mask );
466	}
467
468	VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_NOEXCEPT
469	{
470	return Flags<BitType>( m_mask ^ FlagTraits<BitType>::allFlags.m_mask );
471	}
472
473	// assignment operators
474	VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
475
476	VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator|=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
477	{
478	m_mask |= rhs.m_mask;
479	return *this;
480	}
481
482	VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator&=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
483	{
484	m_mask &= rhs.m_mask;
485	return *this;
486	}
487
488	VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator^=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
489	{
490	m_mask ^= rhs.m_mask;
491	return *this;
492	}
493
494	// cast operators
495	explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT
496	{
497	return !!m_mask;
498	}
499
500	explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT
501	{
502	return m_mask;
503	}
504
505	#if defined( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC )
506	public:
507	#else
508	private:
509	#endif
510	MaskType m_mask;
511	};
512
513	#if !defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
514	// relational operators only needed for pre C++20
515	template <typename BitType>
516	VULKAN_HPP_CONSTEXPR bool operator<( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
517	{
518	return flags.operator>( bit );
519	}
520
521	template <typename BitType>
522	VULKAN_HPP_CONSTEXPR bool operator<=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
523	{
524	return flags.operator>=( bit );
525	}
526
527	template <typename BitType>
528	VULKAN_HPP_CONSTEXPR bool operator>( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
529	{
530	return flags.operator<( bit );
531	}
532
533	template <typename BitType>
534	VULKAN_HPP_CONSTEXPR bool operator>=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
535	{
536	return flags.operator<=( bit );
537	}
538
539	template <typename BitType>
540	VULKAN_HPP_CONSTEXPR bool operator==( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
541	{
542	return flags.operator==( bit );
543	}
544
545	template <typename BitType>
546	VULKAN_HPP_CONSTEXPR bool operator!=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
547	{
548	return flags.operator!=( bit );
549	}
550	#endif
551
552	// bitwise operators
553	template <typename BitType>
554	VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
555	{
556	return flags.operator&( bit );
557	}
558
559	template <typename BitType>
560	VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
561	{
562	return flags.operator|( bit );
563	}
564
565	template <typename BitType>
566	VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
567	{
568	return flags.operator^( bit );
569	}
570
571	// bitwise operators on BitType
572	template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
573	VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator&(BitType lhs, BitType rhs) VULKAN_HPP_NOEXCEPT
574	{
575	return Flags<BitType>( lhs ) & rhs;
576	}
577
578	template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
579	VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator|(BitType lhs, BitType rhs) VULKAN_HPP_NOEXCEPT
580	{
581	return Flags<BitType>( lhs ) | rhs;
582	}
583
584	template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
585	VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator^(BitType lhs, BitType rhs) VULKAN_HPP_NOEXCEPT
586	{
587	return Flags<BitType>( lhs ) ^ rhs;
588	}
589
590	template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
591	VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator~( BitType bit ) VULKAN_HPP_NOEXCEPT
592	{
593	return ~( Flags<BitType>( bit ) );
594	}
595
596
597	#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
598	template <typename T>
599	class ArrayProxy
600	{
601	public:
602	VULKAN_HPP_CONSTEXPR ArrayProxy() VULKAN_HPP_NOEXCEPT
603	: m_count( 0 )
604	, m_ptr( nullptr )
605	{}
606
607	VULKAN_HPP_CONSTEXPR ArrayProxy( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
608	: m_count( 0 )
609	, m_ptr( nullptr )
610	{}
611
612	ArrayProxy( T const & value ) VULKAN_HPP_NOEXCEPT
613	: m_count( 1 )
614	, m_ptr( &value )
615	{}
616
617	ArrayProxy( uint32_t count, T const * ptr ) VULKAN_HPP_NOEXCEPT
618	: m_count( count )
619	, m_ptr( ptr )
620	{}
621
622	template <std::size_t C>
623	ArrayProxy( T const ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
624	: m_count( C )
625	, m_ptr( ptr )
626	{}
627
628	# if __GNUC__ >= 9
629	# pragma GCC diagnostic push
630	# pragma GCC diagnostic ignored "-Winit-list-lifetime"
631	# endif
632
633	ArrayProxy( std::initializer_list<T> const & list ) VULKAN_HPP_NOEXCEPT
634	: m_count( static_cast<uint32_t>( list.size() ) )
635	, m_ptr( list.begin() )
636	{}
637
638	template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
639	ArrayProxy( std::initializer_list<typename std::remove_const<T>::type> const & list ) VULKAN_HPP_NOEXCEPT
640	: m_count( static_cast<uint32_t>( list.size() ) )
641	, m_ptr( list.begin() )
642	{
643	}
644
645	#if __GNUC__ >= 9
646	# pragma GCC diagnostic pop
647	# endif
648
649	// Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly
650	// convertible to size_t. The const version can capture temporaries, with lifetime ending at end of statement.
651	template <typename V,
652	typename std::enable_if<
653	std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
654	std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
655	ArrayProxy( V const & v ) VULKAN_HPP_NOEXCEPT
656	: m_count( static_cast<uint32_t>( v.size() ) )
657	, m_ptr( v.data() )
658	{}
659
660	const T * begin() const VULKAN_HPP_NOEXCEPT
661	{
662	return m_ptr;
663	}
664
665	const T * end() const VULKAN_HPP_NOEXCEPT
666	{
667	return m_ptr + m_count;
668	}
669
670	const T & front() const VULKAN_HPP_NOEXCEPT
671	{
672	VULKAN_HPP_ASSERT( m_count && m_ptr );
673	return *m_ptr;
674	}
675
676	const T & back() const VULKAN_HPP_NOEXCEPT
677	{
678	VULKAN_HPP_ASSERT( m_count && m_ptr );
679	return *( m_ptr + m_count - 1 );
680	}
681
682	bool empty() const VULKAN_HPP_NOEXCEPT
683	{
684	return ( m_count == 0 );
685	}
686
687	uint32_t size() const VULKAN_HPP_NOEXCEPT
688	{
689	return m_count;
690	}
691
692	T const * data() const VULKAN_HPP_NOEXCEPT
693	{
694	return m_ptr;
695	}
696
697	private:
698	uint32_t m_count;
699	T const * m_ptr;
700	};
701
702	template <typename T>
703	class ArrayProxyNoTemporaries
704	{
705	public:
706	VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries() VULKAN_HPP_NOEXCEPT
707	: m_count( 0 )
708	, m_ptr( nullptr )
709	{}
710
711	VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
712	: m_count( 0 )
713	, m_ptr( nullptr )
714	{}
715
716	ArrayProxyNoTemporaries( T & value ) VULKAN_HPP_NOEXCEPT
717	: m_count( 1 )
718	, m_ptr( &value )
719	{}
720
721	template <typename V>
722	ArrayProxyNoTemporaries( V && value ) = delete;
723
724	template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
725	ArrayProxyNoTemporaries( typename std::remove_const<T>::type & value ) VULKAN_HPP_NOEXCEPT
726	: m_count( 1 )
727	, m_ptr( &value )
728	{}
729
730	template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
731	ArrayProxyNoTemporaries( typename std::remove_const<T>::type && value ) = delete;
732
733	ArrayProxyNoTemporaries( uint32_t count, T * ptr ) VULKAN_HPP_NOEXCEPT
734	: m_count( count )
735	, m_ptr( ptr )
736	{}
737
738	template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
739	ArrayProxyNoTemporaries( uint32_t count, typename std::remove_const<T>::type * ptr ) VULKAN_HPP_NOEXCEPT
740	: m_count( count )
741	, m_ptr( ptr )
742	{}
743
744	template <std::size_t C>
745	ArrayProxyNoTemporaries( T (& ptr)[C] ) VULKAN_HPP_NOEXCEPT
746	: m_count( C )
747	, m_ptr( ptr )
748	{}
749
750	template <std::size_t C>
751	ArrayProxyNoTemporaries( T (&& ptr)[C] ) = delete;
752
753	template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
754	ArrayProxyNoTemporaries( typename std::remove_const<T>::type (& ptr)[C] ) VULKAN_HPP_NOEXCEPT
755	: m_count( C )
756	, m_ptr( ptr )
757	{}
758
759	template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
760	ArrayProxyNoTemporaries( typename std::remove_const<T>::type (&& ptr)[C] ) = delete;
761
762	ArrayProxyNoTemporaries( std::initializer_list<T> const & list ) VULKAN_HPP_NOEXCEPT
763	: m_count( static_cast<uint32_t>( list.size() ) )
764	, m_ptr( list.begin() )
765	{}
766
767	ArrayProxyNoTemporaries( std::initializer_list<T> const && list ) = delete;
768
769	template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
770	ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> const & list )
771	VULKAN_HPP_NOEXCEPT
772	: m_count( static_cast<uint32_t>( list.size() ) )
773	, m_ptr( list.begin() )
774	{}
775
776	template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
777	ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> const && list ) = delete;
778
779	ArrayProxyNoTemporaries( std::initializer_list<T> & list ) VULKAN_HPP_NOEXCEPT
780	: m_count( static_cast<uint32_t>( list.size() ) )
781	, m_ptr( list.begin() )
782	{}
783
784	ArrayProxyNoTemporaries( std::initializer_list<T> && list ) = delete;
785
786	template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
787	ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> & list ) VULKAN_HPP_NOEXCEPT
788	: m_count( static_cast<uint32_t>( list.size() ) )
789	, m_ptr( list.begin() )
790	{}
791
792	template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
793	ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> && list ) = delete;
794
795	// Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly convertible to size_t.
796	template <typename V,
797	typename std::enable_if<
798	std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
799	std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
800	ArrayProxyNoTemporaries( V & v ) VULKAN_HPP_NOEXCEPT
801	: m_count( static_cast<uint32_t>( v.size() ) )
802	, m_ptr( v.data() )
803	{}
804
805	const T * begin() const VULKAN_HPP_NOEXCEPT
806	{
807	return m_ptr;
808	}
809
810	const T * end() const VULKAN_HPP_NOEXCEPT
811	{
812	return m_ptr + m_count;
813	}
814
815	const T & front() const VULKAN_HPP_NOEXCEPT
816	{
817	VULKAN_HPP_ASSERT( m_count && m_ptr );
818	return *m_ptr;
819	}
820
821	const T & back() const VULKAN_HPP_NOEXCEPT
822	{
823	VULKAN_HPP_ASSERT( m_count && m_ptr );
824	return *( m_ptr + m_count - 1 );
825	}
826
827	bool empty() const VULKAN_HPP_NOEXCEPT
828	{
829	return ( m_count == 0 );
830	}
831
832	uint32_t size() const VULKAN_HPP_NOEXCEPT
833	{
834	return m_count;
835	}
836
837	T * data() const VULKAN_HPP_NOEXCEPT
838	{
839	return m_ptr;
840	}
841
842	private:
843	uint32_t m_count;
844	T * m_ptr;
845	};
846
847	template <typename T>
848	class StridedArrayProxy : protected ArrayProxy<T>
849	{
850	public:
851	using ArrayProxy<T>::ArrayProxy;
852
853	StridedArrayProxy( uint32_t count, T const * ptr, uint32_t stride ) VULKAN_HPP_NOEXCEPT
854	: ArrayProxy<T>( count, ptr )
855	, m_stride( stride )
856	{
857	VULKAN_HPP_ASSERT( sizeof( T ) <= stride );
858	}
859
860	using ArrayProxy<T>::begin;
861
862	const T * end() const VULKAN_HPP_NOEXCEPT
863	{
864	return reinterpret_cast<T const *>( static_cast<uint8_t const *>( begin() ) + size() * m_stride );
865	}
866
867	using ArrayProxy<T>::front;
868
869	const T & back() const VULKAN_HPP_NOEXCEPT
870	{
871	VULKAN_HPP_ASSERT( begin() && size() );
872	return *reinterpret_cast<T const *>( static_cast<uint8_t const *>( begin() ) + ( size() - 1 ) * m_stride );
873	}
874
875	using ArrayProxy<T>::empty;
876	using ArrayProxy<T>::size;
877	using ArrayProxy<T>::data;
878
879	uint32_t stride() const
880	{
881	return m_stride;
882	}
883
884	private:
885	uint32_t m_stride = sizeof( T );
886	};
887
888	template <typename RefType>
889	class Optional
890	{
891	public:
892	Optional( RefType & reference ) VULKAN_HPP_NOEXCEPT
893	{
894	m_ptr = &reference;
895	}
896	Optional( RefType * ptr ) VULKAN_HPP_NOEXCEPT
897	{
898	m_ptr = ptr;
899	}
900	Optional( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
901	{
902	m_ptr = nullptr;
903	}
904
905	operator RefType *() const VULKAN_HPP_NOEXCEPT
906	{
907	return m_ptr;
908	}
909	RefType const * operator->() const VULKAN_HPP_NOEXCEPT
910	{
911	return m_ptr;
912	}
913	explicit operator bool() const VULKAN_HPP_NOEXCEPT
914	{
915	return !!m_ptr;
916	}
917
918	private:
919	RefType * m_ptr;
920	};
921
922	template <typename X, typename Y>
923	struct StructExtends
924	{
925	enum
926	{
927	value = false
928	};
929	};
930
931	template <typename Type, class...>
932	struct IsPartOfStructureChain
933	{
934	static const bool valid = false;
935	};
936
937	template <typename Type, typename Head, typename... Tail>
938	struct IsPartOfStructureChain<Type, Head, Tail...>
939	{
940	static const bool valid = std::is_same<Type, Head>::value || IsPartOfStructureChain<Type, Tail...>::valid;
941	};
942
943	template <size_t Index, typename T, typename... ChainElements>
944	struct StructureChainContains
945	{
946	static const bool value =
947	std::is_same<T, typename std::tuple_element<Index, std::tuple<ChainElements...>>::type>::value ||
948	StructureChainContains<Index - 1, T, ChainElements...>::value;
949	};
950
951	template <typename T, typename... ChainElements>
952	struct StructureChainContains<0, T, ChainElements...>
953	{
954	static const bool value =
955	std::is_same<T, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value;
956	};
957
958	template <size_t Index, typename... ChainElements>
959	struct StructureChainValidation
960	{
961	using TestType = typename std::tuple_element<Index, std::tuple<ChainElements...>>::type;
962	static const bool valid =
963	StructExtends<TestType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value &&
964	( TestType::allowDuplicate || !StructureChainContains<Index - 1, TestType, ChainElements...>::value ) &&
965	StructureChainValidation<Index - 1, ChainElements...>::valid;
966	};
967
968	template <typename... ChainElements>
969	struct StructureChainValidation<0, ChainElements...>
970	{
971	static const bool valid = true;
972	};
973
974	template <typename... ChainElements>
975	class StructureChain : public std::tuple<ChainElements...>
976	{
977	public:
978	StructureChain() VULKAN_HPP_NOEXCEPT
979	{
980	static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid,
981	"The structure chain is not valid!" );
982	link<sizeof...( ChainElements ) - 1>();
983	}
984
985	StructureChain( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( rhs )
986	{
987	static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid,
988	"The structure chain is not valid!" );
989	link( &std::get<0>( *this ),
990	&std::get<0>( rhs ),
991	reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
992	reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
993	}
994
995	StructureChain( StructureChain && rhs ) VULKAN_HPP_NOEXCEPT
996	: std::tuple<ChainElements...>( std::forward<std::tuple<ChainElements...>>( rhs ) )
997	{
998	static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid,
999	"The structure chain is not valid!" );
1000	link( &std::get<0>( *this ),
1001	&std::get<0>( rhs ),
1002	reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
1003	reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
1004	}
1005
1006	StructureChain( ChainElements const &... elems ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( elems... )
1007	{
1008	static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid,
1009	"The structure chain is not valid!" );
1010	link<sizeof...( ChainElements ) - 1>();
1011	}
1012
1013	StructureChain & operator=( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT
1014	{
1015	std::tuple<ChainElements...>::operator=( rhs );
1016	link( &std::get<0>( *this ),
1017	&std::get<0>( rhs ),
1018	reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
1019	reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
1020	return *this;
1021	}
1022
1023	StructureChain & operator=( StructureChain && rhs ) = delete;
1024
1025	template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
1026	T & get() VULKAN_HPP_NOEXCEPT
1027	{
1028	return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>(
1029	static_cast<std::tuple<ChainElements...> &>( *this ) );
1030	}
1031
1032	template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
1033	T const & get() const VULKAN_HPP_NOEXCEPT
1034	{
1035	return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>(
1036	static_cast<std::tuple<ChainElements...> const &>( *this ) );
1037	}
1038
1039	template <typename T0, typename T1, typename... Ts>
1040	std::tuple<T0 &, T1 &, Ts &...> get() VULKAN_HPP_NOEXCEPT
1041	{
1042	return std::tie( get<T0>(), get<T1>(), get<Ts>()... );
1043	}
1044
1045	template <typename T0, typename T1, typename... Ts>
1046	std::tuple<T0 const &, T1 const &, Ts const &...> get() const VULKAN_HPP_NOEXCEPT
1047	{
1048	return std::tie( get<T0>(), get<T1>(), get<Ts>()... );
1049	}
1050
1051	template <typename ClassType, size_t Which = 0>
1052	typename std::enable_if<
1053	std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value &&
1054	( Which == 0 ),
1055	bool>::type
1056	isLinked() const VULKAN_HPP_NOEXCEPT
1057	{
1058	return true;
1059	}
1060
1061	template <typename ClassType, size_t Which = 0>
1062	typename std::enable_if<
1063	!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value ||
1064	( Which != 0 ),
1065	bool>::type
1066	isLinked() const VULKAN_HPP_NOEXCEPT
1067	{
1068	static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid,
1069	"Can't unlink Structure that's not part of this StructureChain!" );
1070	return isLinked( reinterpret_cast<VkBaseInStructure const *>( &get<ClassType, Which>() ) );
1071	}
1072
1073	template <typename ClassType, size_t Which = 0>
1074	typename std::enable_if<
1075	!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value ||
1076	( Which != 0 ),
1077	void>::type relink() VULKAN_HPP_NOEXCEPT
1078	{
1079	static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid,
1080	"Can't relink Structure that's not part of this StructureChain!" );
1081	auto pNext = reinterpret_cast<VkBaseInStructure *>( &get<ClassType, Which>() );
1082	VULKAN_HPP_ASSERT( !isLinked( pNext ) );
1083	auto & headElement = std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) );
1084	pNext->pNext = reinterpret_cast<VkBaseInStructure const *>( headElement.pNext );
1085	headElement.pNext = pNext;
1086	}
1087
1088	template <typename ClassType, size_t Which = 0>
1089	typename std::enable_if<
1090	!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value ||
1091	( Which != 0 ),
1092	void>::type unlink() VULKAN_HPP_NOEXCEPT
1093	{
1094	static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid,
1095	"Can't unlink Structure that's not part of this StructureChain!" );
1096	unlink( reinterpret_cast<VkBaseOutStructure const *>( &get<ClassType, Which>() ) );
1097	}
1098
1099	private:
1100	template <int Index, typename T, int Which, typename, class First, class... Types>
1101	struct ChainElementIndex : ChainElementIndex<Index + 1, T, Which, void, Types...>
1102	{};
1103
1104	template <int Index, typename T, int Which, class First, class... Types>
1105	struct ChainElementIndex<Index,
1106	T,
1107	Which,
1108	typename std::enable_if<!std::is_same<T, First>::value, void>::type,
1109	First,
1110	Types...> : ChainElementIndex<Index + 1, T, Which, void, Types...>
1111	{};
1112
1113	template <int Index, typename T, int Which, class First, class... Types>
1114	struct ChainElementIndex<Index,
1115	T,
1116	Which,
1117	typename std::enable_if<std::is_same<T, First>::value, void>::type,
1118	First,
1119	Types...> : ChainElementIndex<Index + 1, T, Which - 1, void, Types...>
1120	{};
1121
1122	template <int Index, typename T, class First, class... Types>
1123	struct ChainElementIndex<Index,
1124	T,
1125	0,
1126	typename std::enable_if<std::is_same<T, First>::value, void>::type,
1127	First,
1128	Types...> : std::integral_constant<int, Index>
1129	{};
1130
1131	bool isLinked( VkBaseInStructure const * pNext ) const VULKAN_HPP_NOEXCEPT
1132	{
1133	VkBaseInStructure const * elementPtr = reinterpret_cast<VkBaseInStructure const *>(
1134	&std::get<0>( static_cast<std::tuple<ChainElements...> const &>( *this ) ) );
1135	while ( elementPtr )
1136	{
1137	if ( elementPtr->pNext == pNext )
1138	{
1139	return true;
1140	}
1141	elementPtr = elementPtr->pNext;
1142	}
1143	return false;
1144	}
1145
1146	template <size_t Index>
1147	typename std::enable_if<Index != 0, void>::type link() VULKAN_HPP_NOEXCEPT
1148	{
1149	auto & x = std::get<Index - 1>( static_cast<std::tuple<ChainElements...> &>( *this ) );
1150	x.pNext = &std::get<Index>( static_cast<std::tuple<ChainElements...> &>( *this ) );
1151	link<Index - 1>();
1152	}
1153
1154	template <size_t Index>
1155	typename std::enable_if<Index == 0, void>::type link() VULKAN_HPP_NOEXCEPT
1156	{}
1157
1158	void link( void * dstBase, void const * srcBase, VkBaseOutStructure * dst, VkBaseInStructure const * src )
1159	{
1160	while ( src->pNext )
1161	{
1162	std::ptrdiff_t offset =
1163	reinterpret_cast<char const *>( src->pNext ) - reinterpret_cast<char const *>( srcBase );
1164	dst->pNext = reinterpret_cast<VkBaseOutStructure *>( reinterpret_cast<char *>( dstBase ) + offset );
1165	dst = dst->pNext;
1166	src = src->pNext;
1167	}
1168	dst->pNext = nullptr;
1169	}
1170
1171	void unlink( VkBaseOutStructure const * pNext ) VULKAN_HPP_NOEXCEPT
1172	{
1173	VkBaseOutStructure * elementPtr =
1174	reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) ) );
1175	while ( elementPtr && ( elementPtr->pNext != pNext ) )
1176	{
1177	elementPtr = elementPtr->pNext;
1178	}
1179	if ( elementPtr )
1180	{
1181	elementPtr->pNext = pNext->pNext;
1182	}
1183	else
1184	{
1185	VULKAN_HPP_ASSERT( false ); // fires, if the ClassType member has already been unlinked !
1186	}
1187	}
1188	};
1189
1190	#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
1191	template <typename Type, typename Dispatch>
1192	class UniqueHandleTraits;
1193
1194	template <typename Type, typename Dispatch>
1195	class UniqueHandle : public UniqueHandleTraits<Type, Dispatch>::deleter
1196	{
1197	private:
1198	using Deleter = typename UniqueHandleTraits<Type, Dispatch>::deleter;
1199
1200	public:
1201	using element_type = Type;
1202
1203	UniqueHandle()
1204	: Deleter()
1205	, m_value()
1206	{}
1207
1208	explicit UniqueHandle( Type const & value, Deleter const & deleter = Deleter() ) VULKAN_HPP_NOEXCEPT
1209	: Deleter( deleter )
1210	, m_value( value )
1211	{}
1212
1213	UniqueHandle( UniqueHandle const & ) = delete;
1214
1215	UniqueHandle( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT
1216	: Deleter( std::move( static_cast<Deleter &>( other ) ) )
1217	, m_value( other.release() )
1218	{}
1219
1220	~UniqueHandle() VULKAN_HPP_NOEXCEPT
1221	{
1222	if ( m_value )
1223	{
1224	this->destroy( m_value );
1225	}
1226	}
1227
1228	UniqueHandle & operator=( UniqueHandle const & ) = delete;
1229
1230	UniqueHandle & operator=( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT
1231	{
1232	reset( value: other.release() );
1233	*static_cast<Deleter *>( this ) = std::move( static_cast<Deleter &>( other ) );
1234	return *this;
1235	}
1236
1237	explicit operator bool() const VULKAN_HPP_NOEXCEPT
1238	{
1239	return m_value.operator bool();
1240	}
1241
1242	Type const * operator->() const VULKAN_HPP_NOEXCEPT
1243	{
1244	return &m_value;
1245	}
1246
1247	Type * operator->() VULKAN_HPP_NOEXCEPT
1248	{
1249	return &m_value;
1250	}
1251
1252	Type const & operator*() const VULKAN_HPP_NOEXCEPT
1253	{
1254	return m_value;
1255	}
1256
1257	Type & operator*() VULKAN_HPP_NOEXCEPT
1258	{
1259	return m_value;
1260	}
1261
1262	const Type & get() const VULKAN_HPP_NOEXCEPT
1263	{
1264	return m_value;
1265	}
1266
1267	Type & get() VULKAN_HPP_NOEXCEPT
1268	{
1269	return m_value;
1270	}
1271
1272	void reset( Type const & value = Type() ) VULKAN_HPP_NOEXCEPT
1273	{
1274	if ( m_value != value )
1275	{
1276	if ( m_value )
1277	{
1278	this->destroy( m_value );
1279	}
1280	m_value = value;
1281	}
1282	}
1283
1284	Type release() VULKAN_HPP_NOEXCEPT
1285	{
1286	Type value = m_value;
1287	m_value = nullptr;
1288	return value;
1289	}
1290
1291	void swap( UniqueHandle<Type, Dispatch> & rhs ) VULKAN_HPP_NOEXCEPT
1292	{
1293	std::swap( m_value, rhs.m_value );
1294	std::swap( static_cast<Deleter &>( *this ), static_cast<Deleter &>( rhs ) );
1295	}
1296
1297	private:
1298	Type m_value;
1299	};
1300
1301	template <typename UniqueType>
1302	VULKAN_HPP_INLINE std::vector<typename UniqueType::element_type>
1303	uniqueToRaw( std::vector<UniqueType> const & handles )
1304	{
1305	std::vector<typename UniqueType::element_type> newBuffer( handles.size() );
1306	std::transform( handles.begin(), handles.end(), newBuffer.begin(), []( UniqueType const & handle ) { return handle.get(); } );
1307	return newBuffer;
1308	}
1309
1310	template <typename Type, typename Dispatch>
1311	VULKAN_HPP_INLINE void swap( UniqueHandle<Type, Dispatch> & lhs,
1312	UniqueHandle<Type, Dispatch> & rhs ) VULKAN_HPP_NOEXCEPT
1313	{
1314	lhs.swap( rhs );
1315	}
1316	#endif
1317	#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
1318
1319	class DispatchLoaderBase
1320	{
1321	public:
1322	DispatchLoaderBase() = default;
1323	DispatchLoaderBase( std::nullptr_t )
1324	#if !defined( NDEBUG )
1325	: m_valid( false )
1326	#endif
1327	{}
1328
1329	#if !defined( NDEBUG )
1330	size_t getVkHeaderVersion() const
1331	{
1332	VULKAN_HPP_ASSERT( m_valid );
1333	return vkHeaderVersion;
1334	}
1335
1336	private:
1337	size_t vkHeaderVersion = VK_HEADER_VERSION;
1338	bool m_valid = true;
1339	#endif
1340	};
1341
1342
1343	#if !defined( VK_NO_PROTOTYPES )
1344	class DispatchLoaderStatic : public DispatchLoaderBase
1345	{
1346	public:
1347
1348	//=== VK_VERSION_1_0 ===
1349
1350
1351	VkResult vkCreateInstance( const VkInstanceCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkInstance * pInstance ) const VULKAN_HPP_NOEXCEPT
1352	{
1353	return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance );
1354	}
1355
1356
1357	void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1358	{
1359	return ::vkDestroyInstance( instance, pAllocator );
1360	}
1361
1362
1363	VkResult vkEnumeratePhysicalDevices( VkInstance instance, uint32_t * pPhysicalDeviceCount, VkPhysicalDevice * pPhysicalDevices ) const VULKAN_HPP_NOEXCEPT
1364	{
1365	return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices );
1366	}
1367
1368
1369	void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures * pFeatures ) const VULKAN_HPP_NOEXCEPT
1370	{
1371	return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures );
1372	}
1373
1374
1375	void vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
1376	{
1377	return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties );
1378	}
1379
1380
1381	VkResult vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
1382	{
1383	return ::vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties );
1384	}
1385
1386
1387	void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
1388	{
1389	return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties );
1390	}
1391
1392
1393	void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, uint32_t * pQueueFamilyPropertyCount, VkQueueFamilyProperties * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
1394	{
1395	return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
1396	}
1397
1398
1399	void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
1400	{
1401	return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties );
1402	}
1403
1404
1405	PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char * pName ) const VULKAN_HPP_NOEXCEPT
1406	{
1407	return ::vkGetInstanceProcAddr( instance, pName );
1408	}
1409
1410
1411	PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char * pName ) const VULKAN_HPP_NOEXCEPT
1412	{
1413	return ::vkGetDeviceProcAddr( device, pName );
1414	}
1415
1416
1417	VkResult vkCreateDevice( VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkDevice * pDevice ) const VULKAN_HPP_NOEXCEPT
1418	{
1419	return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice );
1420	}
1421
1422
1423	void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1424	{
1425	return ::vkDestroyDevice( device, pAllocator );
1426	}
1427
1428
1429	VkResult vkEnumerateInstanceExtensionProperties( const char * pLayerName, uint32_t * pPropertyCount, VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
1430	{
1431	return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties );
1432	}
1433
1434
1435	VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, const char * pLayerName, uint32_t * pPropertyCount, VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
1436	{
1437	return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties );
1438	}
1439
1440
1441	VkResult vkEnumerateInstanceLayerProperties( uint32_t * pPropertyCount, VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
1442	{
1443	return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties );
1444	}
1445
1446
1447	VkResult vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
1448	{
1449	return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties );
1450	}
1451
1452
1453	void vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT
1454	{
1455	return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue );
1456	}
1457
1458
1459	VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
1460	{
1461	return ::vkQueueSubmit( queue, submitCount, pSubmits, fence );
1462	}
1463
1464
1465	VkResult vkQueueWaitIdle( VkQueue queue ) const VULKAN_HPP_NOEXCEPT
1466	{
1467	return ::vkQueueWaitIdle( queue );
1468	}
1469
1470
1471	VkResult vkDeviceWaitIdle( VkDevice device ) const VULKAN_HPP_NOEXCEPT
1472	{
1473	return ::vkDeviceWaitIdle( device );
1474	}
1475
1476
1477	VkResult vkAllocateMemory( VkDevice device, const VkMemoryAllocateInfo * pAllocateInfo, const VkAllocationCallbacks * pAllocator, VkDeviceMemory * pMemory ) const VULKAN_HPP_NOEXCEPT
1478	{
1479	return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory );
1480	}
1481
1482
1483	void vkFreeMemory( VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1484	{
1485	return ::vkFreeMemory( device, memory, pAllocator );
1486	}
1487
1488
1489	VkResult vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void ** ppData ) const VULKAN_HPP_NOEXCEPT
1490	{
1491	return ::vkMapMemory( device, memory, offset, size, flags, ppData );
1492	}
1493
1494
1495	void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const VULKAN_HPP_NOEXCEPT
1496	{
1497	return ::vkUnmapMemory( device, memory );
1498	}
1499
1500
1501	VkResult vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
1502	{
1503	return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
1504	}
1505
1506
1507	VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
1508	{
1509	return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
1510	}
1511
1512
1513	void vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize * pCommittedMemoryInBytes ) const VULKAN_HPP_NOEXCEPT
1514	{
1515	return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes );
1516	}
1517
1518
1519	VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT
1520	{
1521	return ::vkBindBufferMemory( device, buffer, memory, memoryOffset );
1522	}
1523
1524
1525	VkResult vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT
1526	{
1527	return ::vkBindImageMemory( device, image, memory, memoryOffset );
1528	}
1529
1530
1531	void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
1532	{
1533	return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements );
1534	}
1535
1536
1537	void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
1538	{
1539	return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements );
1540	}
1541
1542
1543	void vkGetImageSparseMemoryRequirements( VkDevice device, VkImage image, uint32_t * pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
1544	{
1545	return ::vkGetImageSparseMemoryRequirements( device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
1546	}
1547
1548
1549	void vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t * pPropertyCount, VkSparseImageFormatProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
1550	{
1551	return ::vkGetPhysicalDeviceSparseImageFormatProperties( physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties );
1552	}
1553
1554
1555	VkResult vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo * pBindInfo, VkFence fence ) const VULKAN_HPP_NOEXCEPT
1556	{
1557	return ::vkQueueBindSparse( queue, bindInfoCount, pBindInfo, fence );
1558	}
1559
1560
1561	VkResult vkCreateFence( VkDevice device, const VkFenceCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkFence * pFence ) const VULKAN_HPP_NOEXCEPT
1562	{
1563	return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence );
1564	}
1565
1566
1567	void vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1568	{
1569	return ::vkDestroyFence( device, fence, pAllocator );
1570	}
1571
1572
1573	VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences ) const VULKAN_HPP_NOEXCEPT
1574	{
1575	return ::vkResetFences( device, fenceCount, pFences );
1576	}
1577
1578
1579	VkResult vkGetFenceStatus( VkDevice device, VkFence fence ) const VULKAN_HPP_NOEXCEPT
1580	{
1581	return ::vkGetFenceStatus( device, fence );
1582	}
1583
1584
1585	VkResult vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences, VkBool32 waitAll, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
1586	{
1587	return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout );
1588	}
1589
1590
1591	VkResult vkCreateSemaphore( VkDevice device, const VkSemaphoreCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSemaphore * pSemaphore ) const VULKAN_HPP_NOEXCEPT
1592	{
1593	return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore );
1594	}
1595
1596
1597	void vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1598	{
1599	return ::vkDestroySemaphore( device, semaphore, pAllocator );
1600	}
1601
1602
1603	VkResult vkCreateEvent( VkDevice device, const VkEventCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkEvent * pEvent ) const VULKAN_HPP_NOEXCEPT
1604	{
1605	return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent );
1606	}
1607
1608
1609	void vkDestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1610	{
1611	return ::vkDestroyEvent( device, event, pAllocator );
1612	}
1613
1614
1615	VkResult vkGetEventStatus( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
1616	{
1617	return ::vkGetEventStatus( device, event );
1618	}
1619
1620
1621	VkResult vkSetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
1622	{
1623	return ::vkSetEvent( device, event );
1624	}
1625
1626
1627	VkResult vkResetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
1628	{
1629	return ::vkResetEvent( device, event );
1630	}
1631
1632
1633	VkResult vkCreateQueryPool( VkDevice device, const VkQueryPoolCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkQueryPool * pQueryPool ) const VULKAN_HPP_NOEXCEPT
1634	{
1635	return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool );
1636	}
1637
1638
1639	void vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1640	{
1641	return ::vkDestroyQueryPool( device, queryPool, pAllocator );
1642	}
1643
1644
1645	VkResult vkGetQueryPoolResults( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void * pData, VkDeviceSize stride, VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
1646	{
1647	return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags );
1648	}
1649
1650
1651	VkResult vkCreateBuffer( VkDevice device, const VkBufferCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkBuffer * pBuffer ) const VULKAN_HPP_NOEXCEPT
1652	{
1653	return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer );
1654	}
1655
1656
1657	void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1658	{
1659	return ::vkDestroyBuffer( device, buffer, pAllocator );
1660	}
1661
1662
1663	VkResult vkCreateBufferView( VkDevice device, const VkBufferViewCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkBufferView * pView ) const VULKAN_HPP_NOEXCEPT
1664	{
1665	return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView );
1666	}
1667
1668
1669	void vkDestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1670	{
1671	return ::vkDestroyBufferView( device, bufferView, pAllocator );
1672	}
1673
1674
1675	VkResult vkCreateImage( VkDevice device, const VkImageCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkImage * pImage ) const VULKAN_HPP_NOEXCEPT
1676	{
1677	return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage );
1678	}
1679
1680
1681	void vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1682	{
1683	return ::vkDestroyImage( device, image, pAllocator );
1684	}
1685
1686
1687	void vkGetImageSubresourceLayout( VkDevice device, VkImage image, const VkImageSubresource * pSubresource, VkSubresourceLayout * pLayout ) const VULKAN_HPP_NOEXCEPT
1688	{
1689	return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout );
1690	}
1691
1692
1693	VkResult vkCreateImageView( VkDevice device, const VkImageViewCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkImageView * pView ) const VULKAN_HPP_NOEXCEPT
1694	{
1695	return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView );
1696	}
1697
1698
1699	void vkDestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1700	{
1701	return ::vkDestroyImageView( device, imageView, pAllocator );
1702	}
1703
1704
1705	VkResult vkCreateShaderModule( VkDevice device, const VkShaderModuleCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkShaderModule * pShaderModule ) const VULKAN_HPP_NOEXCEPT
1706	{
1707	return ::vkCreateShaderModule( device, pCreateInfo, pAllocator, pShaderModule );
1708	}
1709
1710
1711	void vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1712	{
1713	return ::vkDestroyShaderModule( device, shaderModule, pAllocator );
1714	}
1715
1716
1717	VkResult vkCreatePipelineCache( VkDevice device, const VkPipelineCacheCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkPipelineCache * pPipelineCache ) const VULKAN_HPP_NOEXCEPT
1718	{
1719	return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache );
1720	}
1721
1722
1723	void vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1724	{
1725	return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator );
1726	}
1727
1728
1729	VkResult vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
1730	{
1731	return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData );
1732	}
1733
1734
1735	VkResult vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
1736	{
1737	return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches );
1738	}
1739
1740
1741	VkResult vkCreateGraphicsPipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo * pCreateInfos, const VkAllocationCallbacks * pAllocator, VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
1742	{
1743	return ::vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
1744	}
1745
1746
1747	VkResult vkCreateComputePipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo * pCreateInfos, const VkAllocationCallbacks * pAllocator, VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
1748	{
1749	return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
1750	}
1751
1752
1753	void vkDestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1754	{
1755	return ::vkDestroyPipeline( device, pipeline, pAllocator );
1756	}
1757
1758
1759	VkResult vkCreatePipelineLayout( VkDevice device, const VkPipelineLayoutCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkPipelineLayout * pPipelineLayout ) const VULKAN_HPP_NOEXCEPT
1760	{
1761	return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout );
1762	}
1763
1764
1765	void vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1766	{
1767	return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator );
1768	}
1769
1770
1771	VkResult vkCreateSampler( VkDevice device, const VkSamplerCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSampler * pSampler ) const VULKAN_HPP_NOEXCEPT
1772	{
1773	return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler );
1774	}
1775
1776
1777	void vkDestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1778	{
1779	return ::vkDestroySampler( device, sampler, pAllocator );
1780	}
1781
1782
1783	VkResult vkCreateDescriptorSetLayout( VkDevice device, const VkDescriptorSetLayoutCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkDescriptorSetLayout * pSetLayout ) const VULKAN_HPP_NOEXCEPT
1784	{
1785	return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout );
1786	}
1787
1788
1789	void vkDestroyDescriptorSetLayout( VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1790	{
1791	return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator );
1792	}
1793
1794
1795	VkResult vkCreateDescriptorPool( VkDevice device, const VkDescriptorPoolCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkDescriptorPool * pDescriptorPool ) const VULKAN_HPP_NOEXCEPT
1796	{
1797	return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool );
1798	}
1799
1800
1801	void vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1802	{
1803	return ::vkDestroyDescriptorPool( device, descriptorPool, pAllocator );
1804	}
1805
1806
1807	VkResult vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
1808	{
1809	return ::vkResetDescriptorPool( device, descriptorPool, flags );
1810	}
1811
1812
1813	VkResult vkAllocateDescriptorSets( VkDevice device, const VkDescriptorSetAllocateInfo * pAllocateInfo, VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
1814	{
1815	return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets );
1816	}
1817
1818
1819	VkResult vkFreeDescriptorSets( VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
1820	{
1821	return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets );
1822	}
1823
1824
1825	void vkUpdateDescriptorSets( VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet * pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet * pDescriptorCopies ) const VULKAN_HPP_NOEXCEPT
1826	{
1827	return ::vkUpdateDescriptorSets( device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies );
1828	}
1829
1830
1831	VkResult vkCreateFramebuffer( VkDevice device, const VkFramebufferCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkFramebuffer * pFramebuffer ) const VULKAN_HPP_NOEXCEPT
1832	{
1833	return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer );
1834	}
1835
1836
1837	void vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1838	{
1839	return ::vkDestroyFramebuffer( device, framebuffer, pAllocator );
1840	}
1841
1842
1843	VkResult vkCreateRenderPass( VkDevice device, const VkRenderPassCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT
1844	{
1845	return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass );
1846	}
1847
1848
1849	void vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1850	{
1851	return ::vkDestroyRenderPass( device, renderPass, pAllocator );
1852	}
1853
1854
1855	void vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT
1856	{
1857	return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity );
1858	}
1859
1860
1861	VkResult vkCreateCommandPool( VkDevice device, const VkCommandPoolCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkCommandPool * pCommandPool ) const VULKAN_HPP_NOEXCEPT
1862	{
1863	return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool );
1864	}
1865
1866
1867	void vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1868	{
1869	return ::vkDestroyCommandPool( device, commandPool, pAllocator );
1870	}
1871
1872
1873	VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
1874	{
1875	return ::vkResetCommandPool( device, commandPool, flags );
1876	}
1877
1878
1879	VkResult vkAllocateCommandBuffers( VkDevice device, const VkCommandBufferAllocateInfo * pAllocateInfo, VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
1880	{
1881	return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers );
1882	}
1883
1884
1885	void vkFreeCommandBuffers( VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
1886	{
1887	return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers );
1888	}
1889
1890
1891	VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo * pBeginInfo ) const VULKAN_HPP_NOEXCEPT
1892	{
1893	return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo );
1894	}
1895
1896
1897	VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
1898	{
1899	return ::vkEndCommandBuffer( commandBuffer );
1900	}
1901
1902
1903	VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags ) const VULKAN_HPP_NOEXCEPT
1904	{
1905	return ::vkResetCommandBuffer( commandBuffer, flags );
1906	}
1907
1908
1909	void vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) const VULKAN_HPP_NOEXCEPT
1910	{
1911	return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline );
1912	}
1913
1914
1915	void vkCmdSetViewport( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
1916	{
1917	return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports );
1918	}
1919
1920
1921	void vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
1922	{
1923	return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors );
1924	}
1925
1926
1927	void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const VULKAN_HPP_NOEXCEPT
1928	{
1929	return ::vkCmdSetLineWidth( commandBuffer, lineWidth );
1930	}
1931
1932
1933	void vkCmdSetDepthBias( VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT
1934	{
1935	return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
1936	}
1937
1938
1939	void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT
1940	{
1941	return ::vkCmdSetBlendConstants( commandBuffer, blendConstants );
1942	}
1943
1944
1945	void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT
1946	{
1947	return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds );
1948	}
1949
1950
1951	void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT
1952	{
1953	return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask );
1954	}
1955
1956
1957	void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT
1958	{
1959	return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask );
1960	}
1961
1962
1963	void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT
1964	{
1965	return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference );
1966	}
1967
1968
1969	void vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet * pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t * pDynamicOffsets ) const VULKAN_HPP_NOEXCEPT
1970	{
1971	return ::vkCmdBindDescriptorSets( commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets );
1972	}
1973
1974
1975	void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType ) const VULKAN_HPP_NOEXCEPT
1976	{
1977	return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType );
1978	}
1979
1980
1981	void vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer * pBuffers, const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT
1982	{
1983	return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets );
1984	}
1985
1986
1987	void vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT
1988	{
1989	return ::vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
1990	}
1991
1992
1993	void vkCmdDrawIndexed( VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT
1994	{
1995	return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
1996	}
1997
1998
1999	void vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
2000	{
2001	return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride );
2002	}
2003
2004
2005	void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
2006	{
2007	return ::vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride );
2008	}
2009
2010
2011	void vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
2012	{
2013	return ::vkCmdDispatch( commandBuffer, groupCountX, groupCountY, groupCountZ );
2014	}
2015
2016
2017	void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const VULKAN_HPP_NOEXCEPT
2018	{
2019	return ::vkCmdDispatchIndirect( commandBuffer, buffer, offset );
2020	}
2021
2022
2023	void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
2024	{
2025	return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions );
2026	}
2027
2028
2029	void vkCmdCopyImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
2030	{
2031	return ::vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
2032	}
2033
2034
2035	void vkCmdBlitImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit * pRegions, VkFilter filter ) const VULKAN_HPP_NOEXCEPT
2036	{
2037	return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter );
2038	}
2039
2040
2041	void vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
2042	{
2043	return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions );
2044	}
2045
2046
2047	void vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
2048	{
2049	return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions );
2050	}
2051
2052
2053	void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void * pData ) const VULKAN_HPP_NOEXCEPT
2054	{
2055	return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData );
2056	}
2057
2058
2059	void vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data ) const VULKAN_HPP_NOEXCEPT
2060	{
2061	return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data );
2062	}
2063
2064
2065	void vkCmdClearColorImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue * pColor, uint32_t rangeCount, const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT
2066	{
2067	return ::vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges );
2068	}
2069
2070
2071	void vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue * pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT
2072	{
2073	return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges );
2074	}
2075
2076
2077	void vkCmdClearAttachments( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment * pAttachments, uint32_t rectCount, const VkClearRect * pRects ) const VULKAN_HPP_NOEXCEPT
2078	{
2079	return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects );
2080	}
2081
2082
2083	void vkCmdResolveImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve * pRegions ) const VULKAN_HPP_NOEXCEPT
2084	{
2085	return ::vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
2086	}
2087
2088
2089	void vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
2090	{
2091	return ::vkCmdSetEvent( commandBuffer, event, stageMask );
2092	}
2093
2094
2095	void vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
2096	{
2097	return ::vkCmdResetEvent( commandBuffer, event, stageMask );
2098	}
2099
2100
2101	void vkCmdWaitEvents( VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent * pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier * pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier * pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier * pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
2102	{
2103	return ::vkCmdWaitEvents( commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers );
2104	}
2105
2106
2107	void vkCmdPipelineBarrier( VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier * pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier * pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier * pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
2108	{
2109	return ::vkCmdPipelineBarrier( commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers );
2110	}
2111
2112
2113	void vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT
2114	{
2115	return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags );
2116	}
2117
2118
2119	void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
2120	{
2121	return ::vkCmdEndQuery( commandBuffer, queryPool, query );
2122	}
2123
2124
2125	void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
2126	{
2127	return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount );
2128	}
2129
2130
2131	void vkCmdWriteTimestamp( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
2132	{
2133	return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query );
2134	}
2135
2136
2137	void vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
2138	{
2139	return ::vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags );
2140	}
2141
2142
2143	void vkCmdPushConstants( VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void * pValues ) const VULKAN_HPP_NOEXCEPT
2144	{
2145	return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues );
2146	}
2147
2148
2149	void vkCmdBeginRenderPass( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo * pRenderPassBegin, VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT
2150	{
2151	return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents );
2152	}
2153
2154
2155	void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT
2156	{
2157	return ::vkCmdNextSubpass( commandBuffer, contents );
2158	}
2159
2160
2161	void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
2162	{
2163	return ::vkCmdEndRenderPass( commandBuffer );
2164	}
2165
2166
2167	void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
2168	{
2169	return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers );
2170	}
2171
2172	//=== VK_VERSION_1_1 ===
2173
2174
2175	VkResult vkEnumerateInstanceVersion( uint32_t * pApiVersion ) const VULKAN_HPP_NOEXCEPT
2176	{
2177	return ::vkEnumerateInstanceVersion( pApiVersion );
2178	}
2179
2180
2181	VkResult vkBindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
2182	{
2183	return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos );
2184	}
2185
2186
2187	VkResult vkBindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
2188	{
2189	return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos );
2190	}
2191
2192
2193	void vkGetDeviceGroupPeerMemoryFeatures( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
2194	{
2195	return ::vkGetDeviceGroupPeerMemoryFeatures( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
2196	}
2197
2198
2199	void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
2200	{
2201	return ::vkCmdSetDeviceMask( commandBuffer, deviceMask );
2202	}
2203
2204
2205	void vkCmdDispatchBase( VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
2206	{
2207	return ::vkCmdDispatchBase( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
2208	}
2209
2210
2211	VkResult vkEnumeratePhysicalDeviceGroups( VkInstance instance, uint32_t * pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
2212	{
2213	return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
2214	}
2215
2216
2217	void vkGetImageMemoryRequirements2( VkDevice device, const VkImageMemoryRequirementsInfo2 * pInfo, VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
2218	{
2219	return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements );
2220	}
2221
2222
2223	void vkGetBufferMemoryRequirements2( VkDevice device, const VkBufferMemoryRequirementsInfo2 * pInfo, VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
2224	{
2225	return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements );
2226	}
2227
2228
2229	void vkGetImageSparseMemoryRequirements2( VkDevice device, const VkImageSparseMemoryRequirementsInfo2 * pInfo, uint32_t * pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
2230	{
2231	return ::vkGetImageSparseMemoryRequirements2( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
2232	}
2233
2234
2235	void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT
2236	{
2237	return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures );
2238	}
2239
2240
2241	void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
2242	{
2243	return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties );
2244	}
2245
2246
2247	void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
2248	{
2249	return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties );
2250	}
2251
2252
2253	VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo, VkImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
2254	{
2255	return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties );
2256	}
2257
2258
2259	void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice physicalDevice, uint32_t * pQueueFamilyPropertyCount, VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
2260	{
2261	return ::vkGetPhysicalDeviceQueueFamilyProperties2( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
2262	}
2263
2264
2265	void vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
2266	{
2267	return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties );
2268	}
2269
2270
2271	void vkGetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, uint32_t * pPropertyCount, VkSparseImageFormatProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
2272	{
2273	return ::vkGetPhysicalDeviceSparseImageFormatProperties2( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
2274	}
2275
2276
2277	void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
2278	{
2279	return ::vkTrimCommandPool( device, commandPool, flags );
2280	}
2281
2282
2283	void vkGetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2 * pQueueInfo, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT
2284	{
2285	return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue );
2286	}
2287
2288
2289	VkResult vkCreateSamplerYcbcrConversion( VkDevice device, const VkSamplerYcbcrConversionCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSamplerYcbcrConversion * pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
2290	{
2291	return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion );
2292	}
2293
2294
2295	void vkDestroySamplerYcbcrConversion( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
2296	{
2297	return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator );
2298	}
2299
2300
2301	VkResult vkCreateDescriptorUpdateTemplate( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT
2302	{
2303	return ::vkCreateDescriptorUpdateTemplate( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
2304	}
2305
2306
2307	void vkDestroyDescriptorUpdateTemplate( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
2308	{
2309	return ::vkDestroyDescriptorUpdateTemplate( device, descriptorUpdateTemplate, pAllocator );
2310	}
2311
2312
2313	void vkUpdateDescriptorSetWithTemplate( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void * pData ) const VULKAN_HPP_NOEXCEPT
2314	{
2315	return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData );
2316	}
2317
2318
2319	void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo, VkExternalBufferProperties * pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT
2320	{
2321	return ::vkGetPhysicalDeviceExternalBufferProperties( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
2322	}
2323
2324
2325	void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo, VkExternalFenceProperties * pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT
2326	{
2327	return ::vkGetPhysicalDeviceExternalFenceProperties( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
2328	}
2329
2330
2331	void vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
2332	{
2333	return ::vkGetPhysicalDeviceExternalSemaphoreProperties( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
2334	}
2335
2336
2337	void vkGetDescriptorSetLayoutSupport( VkDevice device, const VkDescriptorSetLayoutCreateInfo * pCreateInfo, VkDescriptorSetLayoutSupport * pSupport ) const VULKAN_HPP_NOEXCEPT
2338	{
2339	return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport );
2340	}
2341
2342	//=== VK_VERSION_1_2 ===
2343
2344
2345	void vkCmdDrawIndirectCount( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
2346	{
2347	return ::vkCmdDrawIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
2348	}
2349
2350
2351	void vkCmdDrawIndexedIndirectCount( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
2352	{
2353	return ::vkCmdDrawIndexedIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
2354	}
2355
2356
2357	VkResult vkCreateRenderPass2( VkDevice device, const VkRenderPassCreateInfo2 * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT
2358	{
2359	return ::vkCreateRenderPass2( device, pCreateInfo, pAllocator, pRenderPass );
2360	}
2361
2362
2363	void vkCmdBeginRenderPass2( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo * pRenderPassBegin, const VkSubpassBeginInfo * pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
2364	{
2365	return ::vkCmdBeginRenderPass2( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
2366	}
2367
2368
2369	void vkCmdNextSubpass2( VkCommandBuffer commandBuffer, const VkSubpassBeginInfo * pSubpassBeginInfo, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
2370	{
2371	return ::vkCmdNextSubpass2( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
2372	}
2373
2374
2375	void vkCmdEndRenderPass2( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
2376	{
2377	return ::vkCmdEndRenderPass2( commandBuffer, pSubpassEndInfo );
2378	}
2379
2380
2381	void vkResetQueryPool( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
2382	{
2383	return ::vkResetQueryPool( device, queryPool, firstQuery, queryCount );
2384	}
2385
2386
2387	VkResult vkGetSemaphoreCounterValue( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
2388	{
2389	return ::vkGetSemaphoreCounterValue( device, semaphore, pValue );
2390	}
2391
2392
2393	VkResult vkWaitSemaphores( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
2394	{
2395	return ::vkWaitSemaphores( device, pWaitInfo, timeout );
2396	}
2397
2398
2399	VkResult vkSignalSemaphore( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
2400	{
2401	return ::vkSignalSemaphore( device, pSignalInfo );
2402	}
2403
2404
2405	VkDeviceAddress vkGetBufferDeviceAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
2406	{
2407	return ::vkGetBufferDeviceAddress( device, pInfo );
2408	}
2409
2410
2411	uint64_t vkGetBufferOpaqueCaptureAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
2412	{
2413	return ::vkGetBufferOpaqueCaptureAddress( device, pInfo );
2414	}
2415
2416
2417	uint64_t vkGetDeviceMemoryOpaqueCaptureAddress( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
2418	{
2419	return ::vkGetDeviceMemoryOpaqueCaptureAddress( device, pInfo );
2420	}
2421
2422	//=== VK_VERSION_1_3 ===
2423
2424
2425	VkResult vkGetPhysicalDeviceToolProperties( VkPhysicalDevice physicalDevice, uint32_t * pToolCount, VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT
2426	{
2427	return ::vkGetPhysicalDeviceToolProperties( physicalDevice, pToolCount, pToolProperties );
2428	}
2429
2430
2431	VkResult vkCreatePrivateDataSlot( VkDevice device, const VkPrivateDataSlotCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkPrivateDataSlot * pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT
2432	{
2433	return ::vkCreatePrivateDataSlot( device, pCreateInfo, pAllocator, pPrivateDataSlot );
2434	}
2435
2436
2437	void vkDestroyPrivateDataSlot( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
2438	{
2439	return ::vkDestroyPrivateDataSlot( device, privateDataSlot, pAllocator );
2440	}
2441
2442
2443	VkResult vkSetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const VULKAN_HPP_NOEXCEPT
2444	{
2445	return ::vkSetPrivateData( device, objectType, objectHandle, privateDataSlot, data );
2446	}
2447
2448
2449	void vkGetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const VULKAN_HPP_NOEXCEPT
2450	{
2451	return ::vkGetPrivateData( device, objectType, objectHandle, privateDataSlot, pData );
2452	}
2453
2454
2455	void vkCmdSetEvent2( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
2456	{
2457	return ::vkCmdSetEvent2( commandBuffer, event, pDependencyInfo );
2458	}
2459
2460
2461	void vkCmdResetEvent2( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
2462	{
2463	return ::vkCmdResetEvent2( commandBuffer, event, stageMask );
2464	}
2465
2466
2467	void vkCmdWaitEvents2( VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent * pEvents, const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT
2468	{
2469	return ::vkCmdWaitEvents2( commandBuffer, eventCount, pEvents, pDependencyInfos );
2470	}
2471
2472
2473	void vkCmdPipelineBarrier2( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
2474	{
2475	return ::vkCmdPipelineBarrier2( commandBuffer, pDependencyInfo );
2476	}
2477
2478
2479	void vkCmdWriteTimestamp2( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
2480	{
2481	return ::vkCmdWriteTimestamp2( commandBuffer, stage, queryPool, query );
2482	}
2483
2484
2485	VkResult vkQueueSubmit2( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
2486	{
2487	return ::vkQueueSubmit2( queue, submitCount, pSubmits, fence );
2488	}
2489
2490
2491	void vkCmdCopyBuffer2( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
2492	{
2493	return ::vkCmdCopyBuffer2( commandBuffer, pCopyBufferInfo );
2494	}
2495
2496
2497	void vkCmdCopyImage2( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT
2498	{
2499	return ::vkCmdCopyImage2( commandBuffer, pCopyImageInfo );
2500	}
2501
2502
2503	void vkCmdCopyBufferToImage2( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
2504	{
2505	return ::vkCmdCopyBufferToImage2( commandBuffer, pCopyBufferToImageInfo );
2506	}
2507
2508
2509	void vkCmdCopyImageToBuffer2( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
2510	{
2511	return ::vkCmdCopyImageToBuffer2( commandBuffer, pCopyImageToBufferInfo );
2512	}
2513
2514
2515	void vkCmdBlitImage2( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT
2516	{
2517	return ::vkCmdBlitImage2( commandBuffer, pBlitImageInfo );
2518	}
2519
2520
2521	void vkCmdResolveImage2( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT
2522	{
2523	return ::vkCmdResolveImage2( commandBuffer, pResolveImageInfo );
2524	}
2525
2526
2527	void vkCmdBeginRendering( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT
2528	{
2529	return ::vkCmdBeginRendering( commandBuffer, pRenderingInfo );
2530	}
2531
2532
2533	void vkCmdEndRendering( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
2534	{
2535	return ::vkCmdEndRendering( commandBuffer );
2536	}
2537
2538
2539	void vkCmdSetCullMode( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
2540	{
2541	return ::vkCmdSetCullMode( commandBuffer, cullMode );
2542	}
2543
2544
2545	void vkCmdSetFrontFace( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
2546	{
2547	return ::vkCmdSetFrontFace( commandBuffer, frontFace );
2548	}
2549
2550
2551	void vkCmdSetPrimitiveTopology( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
2552	{
2553	return ::vkCmdSetPrimitiveTopology( commandBuffer, primitiveTopology );
2554	}
2555
2556
2557	void vkCmdSetViewportWithCount( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
2558	{
2559	return ::vkCmdSetViewportWithCount( commandBuffer, viewportCount, pViewports );
2560	}
2561
2562
2563	void vkCmdSetScissorWithCount( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
2564	{
2565	return ::vkCmdSetScissorWithCount( commandBuffer, scissorCount, pScissors );
2566	}
2567
2568
2569	void vkCmdBindVertexBuffers2( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer * pBuffers, const VkDeviceSize * pOffsets, const VkDeviceSize * pSizes, const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT
2570	{
2571	return ::vkCmdBindVertexBuffers2( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
2572	}
2573
2574
2575	void vkCmdSetDepthTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
2576	{
2577	return ::vkCmdSetDepthTestEnable( commandBuffer, depthTestEnable );
2578	}
2579
2580
2581	void vkCmdSetDepthWriteEnable( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
2582	{
2583	return ::vkCmdSetDepthWriteEnable( commandBuffer, depthWriteEnable );
2584	}
2585
2586
2587	void vkCmdSetDepthCompareOp( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
2588	{
2589	return ::vkCmdSetDepthCompareOp( commandBuffer, depthCompareOp );
2590	}
2591
2592
2593	void vkCmdSetDepthBoundsTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
2594	{
2595	return ::vkCmdSetDepthBoundsTestEnable( commandBuffer, depthBoundsTestEnable );
2596	}
2597
2598
2599	void vkCmdSetStencilTestEnable( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
2600	{
2601	return ::vkCmdSetStencilTestEnable( commandBuffer, stencilTestEnable );
2602	}
2603
2604
2605	void vkCmdSetStencilOp( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp ) const VULKAN_HPP_NOEXCEPT
2606	{
2607	return ::vkCmdSetStencilOp( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
2608	}
2609
2610
2611	void vkCmdSetRasterizerDiscardEnable( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
2612	{
2613	return ::vkCmdSetRasterizerDiscardEnable( commandBuffer, rasterizerDiscardEnable );
2614	}
2615
2616
2617	void vkCmdSetDepthBiasEnable( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
2618	{
2619	return ::vkCmdSetDepthBiasEnable( commandBuffer, depthBiasEnable );
2620	}
2621
2622
2623	void vkCmdSetPrimitiveRestartEnable( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
2624	{
2625	return ::vkCmdSetPrimitiveRestartEnable( commandBuffer, primitiveRestartEnable );
2626	}
2627
2628
2629	void vkGetDeviceBufferMemoryRequirements( VkDevice device, const VkDeviceBufferMemoryRequirements * pInfo, VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
2630	{
2631	return ::vkGetDeviceBufferMemoryRequirements( device, pInfo, pMemoryRequirements );
2632	}
2633
2634
2635	void vkGetDeviceImageMemoryRequirements( VkDevice device, const VkDeviceImageMemoryRequirements * pInfo, VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
2636	{
2637	return ::vkGetDeviceImageMemoryRequirements( device, pInfo, pMemoryRequirements );
2638	}
2639
2640
2641	void vkGetDeviceImageSparseMemoryRequirements( VkDevice device, const VkDeviceImageMemoryRequirements * pInfo, uint32_t * pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
2642	{
2643	return ::vkGetDeviceImageSparseMemoryRequirements( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
2644	}
2645
2646	//=== VK_KHR_surface ===
2647
2648
2649	void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
2650	{
2651	return ::vkDestroySurfaceKHR( instance, surface, pAllocator );
2652	}
2653
2654
2655	VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 * pSupported ) const VULKAN_HPP_NOEXCEPT
2656	{
2657	return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported );
2658	}
2659
2660
2661	VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
2662	{
2663	return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities );
2664	}
2665
2666
2667	VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t * pSurfaceFormatCount, VkSurfaceFormatKHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT
2668	{
2669	return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats );
2670	}
2671
2672
2673	VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t * pPresentModeCount, VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT
2674	{
2675	return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes );
2676	}
2677
2678	//=== VK_KHR_swapchain ===
2679
2680
2681	VkResult vkCreateSwapchainKHR( VkDevice device, const VkSwapchainCreateInfoKHR * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSwapchainKHR * pSwapchain ) const VULKAN_HPP_NOEXCEPT
2682	{
2683	return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain );
2684	}
2685
2686
2687	void vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
2688	{
2689	return ::vkDestroySwapchainKHR( device, swapchain, pAllocator );
2690	}
2691
2692
2693	VkResult vkGetSwapchainImagesKHR( VkDevice device, VkSwapchainKHR swapchain, uint32_t * pSwapchainImageCount, VkImage * pSwapchainImages ) const VULKAN_HPP_NOEXCEPT
2694	{
2695	return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages );
2696	}
2697
2698
2699	VkResult vkAcquireNextImageKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT
2700	{
2701	return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex );
2702	}
2703
2704
2705	VkResult vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR * pPresentInfo ) const VULKAN_HPP_NOEXCEPT
2706	{
2707	return ::vkQueuePresentKHR( queue, pPresentInfo );
2708	}
2709
2710
2711	VkResult vkGetDeviceGroupPresentCapabilitiesKHR( VkDevice device, VkDeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities ) const VULKAN_HPP_NOEXCEPT
2712	{
2713	return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities );
2714	}
2715
2716
2717	VkResult vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR * pModes ) const VULKAN_HPP_NOEXCEPT
2718	{
2719	return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes );
2720	}
2721
2722
2723	VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t * pRectCount, VkRect2D * pRects ) const VULKAN_HPP_NOEXCEPT
2724	{
2725	return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects );
2726	}
2727
2728
2729	VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR * pAcquireInfo, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT
2730	{
2731	return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex );
2732	}
2733
2734	//=== VK_KHR_display ===
2735
2736
2737	VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkDisplayPropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
2738	{
2739	return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties );
2740	}
2741
2742
2743	VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkDisplayPlanePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
2744	{
2745	return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties );
2746	}
2747
2748
2749	VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t * pDisplayCount, VkDisplayKHR * pDisplays ) const VULKAN_HPP_NOEXCEPT
2750	{
2751	return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays );
2752	}
2753
2754
2755	VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t * pPropertyCount, VkDisplayModePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
2756	{
2757	return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties );
2758	}
2759
2760
2761	VkResult vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkDisplayModeKHR * pMode ) const VULKAN_HPP_NOEXCEPT
2762	{
2763	return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode );
2764	}
2765
2766
2767	VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
2768	{
2769	return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities );
2770	}
2771
2772
2773	VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance instance, const VkDisplaySurfaceCreateInfoKHR * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
2774	{
2775	return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
2776	}
2777
2778	//=== VK_KHR_display_swapchain ===
2779
2780
2781	VkResult vkCreateSharedSwapchainsKHR( VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR * pCreateInfos, const VkAllocationCallbacks * pAllocator, VkSwapchainKHR * pSwapchains ) const VULKAN_HPP_NOEXCEPT
2782	{
2783	return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains );
2784	}
2785
2786	#if defined( VK_USE_PLATFORM_XLIB_KHR )
2787	//=== VK_KHR_xlib_surface ===
2788
2789
2790	VkResult vkCreateXlibSurfaceKHR( VkInstance instance, const VkXlibSurfaceCreateInfoKHR * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
2791	{
2792	return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
2793	}
2794
2795
2796	VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display * dpy, VisualID visualID ) const VULKAN_HPP_NOEXCEPT
2797	{
2798	return ::vkGetPhysicalDeviceXlibPresentationSupportKHR( physicalDevice, queueFamilyIndex, dpy, visualID );
2799	}
2800	#endif /*VK_USE_PLATFORM_XLIB_KHR*/
2801
2802	#if defined( VK_USE_PLATFORM_XCB_KHR )
2803	//=== VK_KHR_xcb_surface ===
2804
2805
2806	VkResult vkCreateXcbSurfaceKHR( VkInstance instance, const VkXcbSurfaceCreateInfoKHR * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
2807	{
2808	return ::vkCreateXcbSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
2809	}
2810
2811
2812	VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t * connection, xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT
2813	{
2814	return ::vkGetPhysicalDeviceXcbPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection, visual_id );
2815	}
2816	#endif /*VK_USE_PLATFORM_XCB_KHR*/
2817
2818	#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
2819	//=== VK_KHR_wayland_surface ===
2820
2821
2822	VkResult vkCreateWaylandSurfaceKHR( VkInstance instance, const VkWaylandSurfaceCreateInfoKHR * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
2823	{
2824	return ::vkCreateWaylandSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
2825	}
2826
2827
2828	VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display * display ) const VULKAN_HPP_NOEXCEPT
2829	{
2830	return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR( physicalDevice, queueFamilyIndex, display );
2831	}
2832	#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
2833
2834	#if defined( VK_USE_PLATFORM_ANDROID_KHR )
2835	//=== VK_KHR_android_surface ===
2836
2837
2838	VkResult vkCreateAndroidSurfaceKHR( VkInstance instance, const VkAndroidSurfaceCreateInfoKHR * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
2839	{
2840	return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
2841	}
2842	#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
2843
2844	#if defined( VK_USE_PLATFORM_WIN32_KHR )
2845	//=== VK_KHR_win32_surface ===
2846
2847
2848	VkResult vkCreateWin32SurfaceKHR( VkInstance instance, const VkWin32SurfaceCreateInfoKHR * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
2849	{
2850	return ::vkCreateWin32SurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
2851	}
2852
2853
2854	VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT
2855	{
2856	return ::vkGetPhysicalDeviceWin32PresentationSupportKHR( physicalDevice, queueFamilyIndex );
2857	}
2858	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
2859
2860	//=== VK_EXT_debug_report ===
2861
2862
2863	VkResult vkCreateDebugReportCallbackEXT( VkInstance instance, const VkDebugReportCallbackCreateInfoEXT * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkDebugReportCallbackEXT * pCallback ) const VULKAN_HPP_NOEXCEPT
2864	{
2865	return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback );
2866	}
2867
2868
2869	void vkDestroyDebugReportCallbackEXT( VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
2870	{
2871	return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator );
2872	}
2873
2874
2875	void vkDebugReportMessageEXT( VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char * pLayerPrefix, const char * pMessage ) const VULKAN_HPP_NOEXCEPT
2876	{
2877	return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage );
2878	}
2879
2880	//=== VK_EXT_debug_marker ===
2881
2882
2883	VkResult vkDebugMarkerSetObjectTagEXT( VkDevice device, const VkDebugMarkerObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT
2884	{
2885	return ::vkDebugMarkerSetObjectTagEXT( device, pTagInfo );
2886	}
2887
2888
2889	VkResult vkDebugMarkerSetObjectNameEXT( VkDevice device, const VkDebugMarkerObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT
2890	{
2891	return ::vkDebugMarkerSetObjectNameEXT( device, pNameInfo );
2892	}
2893
2894
2895	void vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
2896	{
2897	return ::vkCmdDebugMarkerBeginEXT( commandBuffer, pMarkerInfo );
2898	}
2899
2900
2901	void vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
2902	{
2903	return ::vkCmdDebugMarkerEndEXT( commandBuffer );
2904	}
2905
2906
2907	void vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
2908	{
2909	return ::vkCmdDebugMarkerInsertEXT( commandBuffer, pMarkerInfo );
2910	}
2911
2912	//=== VK_KHR_video_queue ===
2913
2914
2915	VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR( VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR * pVideoProfile, VkVideoCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
2916	{
2917	return ::vkGetPhysicalDeviceVideoCapabilitiesKHR( physicalDevice, pVideoProfile, pCapabilities );
2918	}
2919
2920
2921	VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo, uint32_t * pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR * pVideoFormatProperties ) const VULKAN_HPP_NOEXCEPT
2922	{
2923	return ::vkGetPhysicalDeviceVideoFormatPropertiesKHR( physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties );
2924	}
2925
2926
2927	VkResult vkCreateVideoSessionKHR( VkDevice device, const VkVideoSessionCreateInfoKHR * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkVideoSessionKHR * pVideoSession ) const VULKAN_HPP_NOEXCEPT
2928	{
2929	return ::vkCreateVideoSessionKHR( device, pCreateInfo, pAllocator, pVideoSession );
2930	}
2931
2932
2933	void vkDestroyVideoSessionKHR( VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
2934	{
2935	return ::vkDestroyVideoSessionKHR( device, videoSession, pAllocator );
2936	}
2937
2938
2939	VkResult vkGetVideoSessionMemoryRequirementsKHR( VkDevice device, VkVideoSessionKHR videoSession, uint32_t * pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
2940	{
2941	return ::vkGetVideoSessionMemoryRequirementsKHR( device, videoSession, pMemoryRequirementsCount, pMemoryRequirements );
2942	}
2943
2944
2945	VkResult vkBindVideoSessionMemoryKHR( VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos ) const VULKAN_HPP_NOEXCEPT
2946	{
2947	return ::vkBindVideoSessionMemoryKHR( device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos );
2948	}
2949
2950
2951	VkResult vkCreateVideoSessionParametersKHR( VkDevice device, const VkVideoSessionParametersCreateInfoKHR * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkVideoSessionParametersKHR * pVideoSessionParameters ) const VULKAN_HPP_NOEXCEPT
2952	{
2953	return ::vkCreateVideoSessionParametersKHR( device, pCreateInfo, pAllocator, pVideoSessionParameters );
2954	}
2955
2956
2957	VkResult vkUpdateVideoSessionParametersKHR( VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR * pUpdateInfo ) const VULKAN_HPP_NOEXCEPT
2958	{
2959	return ::vkUpdateVideoSessionParametersKHR( device, videoSessionParameters, pUpdateInfo );
2960	}
2961
2962
2963	void vkDestroyVideoSessionParametersKHR( VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
2964	{
2965	return ::vkDestroyVideoSessionParametersKHR( device, videoSessionParameters, pAllocator );
2966	}
2967
2968
2969	void vkCmdBeginVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR * pBeginInfo ) const VULKAN_HPP_NOEXCEPT
2970	{
2971	return ::vkCmdBeginVideoCodingKHR( commandBuffer, pBeginInfo );
2972	}
2973
2974
2975	void vkCmdEndVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR * pEndCodingInfo ) const VULKAN_HPP_NOEXCEPT
2976	{
2977	return ::vkCmdEndVideoCodingKHR( commandBuffer, pEndCodingInfo );
2978	}
2979
2980
2981	void vkCmdControlVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR * pCodingControlInfo ) const VULKAN_HPP_NOEXCEPT
2982	{
2983	return ::vkCmdControlVideoCodingKHR( commandBuffer, pCodingControlInfo );
2984	}
2985
2986	//=== VK_KHR_video_decode_queue ===
2987
2988
2989	void vkCmdDecodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR * pDecodeInfo ) const VULKAN_HPP_NOEXCEPT
2990	{
2991	return ::vkCmdDecodeVideoKHR( commandBuffer, pDecodeInfo );
2992	}
2993
2994	//=== VK_EXT_transform_feedback ===
2995
2996
2997	void vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer * pBuffers, const VkDeviceSize * pOffsets, const VkDeviceSize * pSizes ) const VULKAN_HPP_NOEXCEPT
2998	{
2999	return ::vkCmdBindTransformFeedbackBuffersEXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes );
3000	}
3001
3002
3003	void vkCmdBeginTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer * pCounterBuffers, const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT
3004	{
3005	return ::vkCmdBeginTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
3006	}
3007
3008
3009	void vkCmdEndTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer * pCounterBuffers, const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT
3010	{
3011	return ::vkCmdEndTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
3012	}
3013
3014
3015	void vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index ) const VULKAN_HPP_NOEXCEPT
3016	{
3017	return ::vkCmdBeginQueryIndexedEXT( commandBuffer, queryPool, query, flags, index );
3018	}
3019
3020
3021	void vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT
3022	{
3023	return ::vkCmdEndQueryIndexedEXT( commandBuffer, queryPool, query, index );
3024	}
3025
3026
3027	void vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT
3028	{
3029	return ::vkCmdDrawIndirectByteCountEXT( commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride );
3030	}
3031
3032	//=== VK_NVX_binary_import ===
3033
3034
3035	VkResult vkCreateCuModuleNVX( VkDevice device, const VkCuModuleCreateInfoNVX * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkCuModuleNVX * pModule ) const VULKAN_HPP_NOEXCEPT
3036	{
3037	return ::vkCreateCuModuleNVX( device, pCreateInfo, pAllocator, pModule );
3038	}
3039
3040
3041	VkResult vkCreateCuFunctionNVX( VkDevice device, const VkCuFunctionCreateInfoNVX * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkCuFunctionNVX * pFunction ) const VULKAN_HPP_NOEXCEPT
3042	{
3043	return ::vkCreateCuFunctionNVX( device, pCreateInfo, pAllocator, pFunction );
3044	}
3045
3046
3047	void vkDestroyCuModuleNVX( VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
3048	{
3049	return ::vkDestroyCuModuleNVX( device, module, pAllocator );
3050	}
3051
3052
3053	void vkDestroyCuFunctionNVX( VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
3054	{
3055	return ::vkDestroyCuFunctionNVX( device, function, pAllocator );
3056	}
3057
3058
3059	void vkCmdCuLaunchKernelNVX( VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX * pLaunchInfo ) const VULKAN_HPP_NOEXCEPT
3060	{
3061	return ::vkCmdCuLaunchKernelNVX( commandBuffer, pLaunchInfo );
3062	}
3063
3064	//=== VK_NVX_image_view_handle ===
3065
3066
3067	uint32_t vkGetImageViewHandleNVX( VkDevice device, const VkImageViewHandleInfoNVX * pInfo ) const VULKAN_HPP_NOEXCEPT
3068	{
3069	return ::vkGetImageViewHandleNVX( device, pInfo );
3070	}
3071
3072
3073	VkResult vkGetImageViewAddressNVX( VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX * pProperties ) const VULKAN_HPP_NOEXCEPT
3074	{
3075	return ::vkGetImageViewAddressNVX( device, imageView, pProperties );
3076	}
3077
3078	//=== VK_AMD_draw_indirect_count ===
3079
3080
3081	void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
3082	{
3083	return ::vkCmdDrawIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
3084	}
3085
3086
3087	void vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
3088	{
3089	return ::vkCmdDrawIndexedIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
3090	}
3091
3092	//=== VK_AMD_shader_info ===
3093
3094
3095	VkResult vkGetShaderInfoAMD( VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t * pInfoSize, void * pInfo ) const VULKAN_HPP_NOEXCEPT
3096	{
3097	return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo );
3098	}
3099
3100	//=== VK_KHR_dynamic_rendering ===
3101
3102
3103	void vkCmdBeginRenderingKHR( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT
3104	{
3105	return ::vkCmdBeginRenderingKHR( commandBuffer, pRenderingInfo );
3106	}
3107
3108
3109	void vkCmdEndRenderingKHR( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
3110	{
3111	return ::vkCmdEndRenderingKHR( commandBuffer );
3112	}
3113
3114	#if defined( VK_USE_PLATFORM_GGP )
3115	//=== VK_GGP_stream_descriptor_surface ===
3116
3117
3118	VkResult vkCreateStreamDescriptorSurfaceGGP( VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
3119	{
3120	return ::vkCreateStreamDescriptorSurfaceGGP( instance, pCreateInfo, pAllocator, pSurface );
3121	}
3122	#endif /*VK_USE_PLATFORM_GGP*/
3123
3124	//=== VK_NV_external_memory_capabilities ===
3125
3126
3127	VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV * pExternalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
3128	{
3129	return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV( physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties );
3130	}
3131
3132	#if defined( VK_USE_PLATFORM_WIN32_KHR )
3133	//=== VK_NV_external_memory_win32 ===
3134
3135
3136	VkResult vkGetMemoryWin32HandleNV( VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
3137	{
3138	return ::vkGetMemoryWin32HandleNV( device, memory, handleType, pHandle );
3139	}
3140	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
3141
3142	//=== VK_KHR_get_physical_device_properties2 ===
3143
3144
3145	void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT
3146	{
3147	return ::vkGetPhysicalDeviceFeatures2KHR( physicalDevice, pFeatures );
3148	}
3149
3150
3151	void vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
3152	{
3153	return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties );
3154	}
3155
3156
3157	void vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
3158	{
3159	return ::vkGetPhysicalDeviceFormatProperties2KHR( physicalDevice, format, pFormatProperties );
3160	}
3161
3162
3163	VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo, VkImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
3164	{
3165	return ::vkGetPhysicalDeviceImageFormatProperties2KHR( physicalDevice, pImageFormatInfo, pImageFormatProperties );
3166	}
3167
3168
3169	void vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t * pQueueFamilyPropertyCount, VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
3170	{
3171	return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
3172	}
3173
3174
3175	void vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
3176	{
3177	return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties );
3178	}
3179
3180
3181	void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, uint32_t * pPropertyCount, VkSparseImageFormatProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
3182	{
3183	return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
3184	}
3185
3186	//=== VK_KHR_device_group ===
3187
3188
3189	void vkGetDeviceGroupPeerMemoryFeaturesKHR( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
3190	{
3191	return ::vkGetDeviceGroupPeerMemoryFeaturesKHR( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
3192	}
3193
3194
3195	void vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
3196	{
3197	return ::vkCmdSetDeviceMaskKHR( commandBuffer, deviceMask );
3198	}
3199
3200
3201	void vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
3202	{
3203	return ::vkCmdDispatchBaseKHR( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
3204	}
3205
3206	#if defined( VK_USE_PLATFORM_VI_NN )
3207	//=== VK_NN_vi_surface ===
3208
3209
3210	VkResult vkCreateViSurfaceNN( VkInstance instance, const VkViSurfaceCreateInfoNN * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
3211	{
3212	return ::vkCreateViSurfaceNN( instance, pCreateInfo, pAllocator, pSurface );
3213	}
3214	#endif /*VK_USE_PLATFORM_VI_NN*/
3215
3216	//=== VK_KHR_maintenance1 ===
3217
3218
3219	void vkTrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
3220	{
3221	return ::vkTrimCommandPoolKHR( device, commandPool, flags );
3222	}
3223
3224	//=== VK_KHR_device_group_creation ===
3225
3226
3227	VkResult vkEnumeratePhysicalDeviceGroupsKHR( VkInstance instance, uint32_t * pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
3228	{
3229	return ::vkEnumeratePhysicalDeviceGroupsKHR( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
3230	}
3231
3232	//=== VK_KHR_external_memory_capabilities ===
3233
3234
3235	void vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo, VkExternalBufferProperties * pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT
3236	{
3237	return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
3238	}
3239
3240	#if defined( VK_USE_PLATFORM_WIN32_KHR )
3241	//=== VK_KHR_external_memory_win32 ===
3242
3243
3244	VkResult vkGetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
3245	{
3246	return ::vkGetMemoryWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
3247	}
3248
3249
3250	VkResult vkGetMemoryWin32HandlePropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties ) const VULKAN_HPP_NOEXCEPT
3251	{
3252	return ::vkGetMemoryWin32HandlePropertiesKHR( device, handleType, handle, pMemoryWin32HandleProperties );
3253	}
3254	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
3255
3256	//=== VK_KHR_external_memory_fd ===
3257
3258
3259	VkResult vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
3260	{
3261	return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd );
3262	}
3263
3264
3265	VkResult vkGetMemoryFdPropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR * pMemoryFdProperties ) const VULKAN_HPP_NOEXCEPT
3266	{
3267	return ::vkGetMemoryFdPropertiesKHR( device, handleType, fd, pMemoryFdProperties );
3268	}
3269
3270	//=== VK_KHR_external_semaphore_capabilities ===
3271
3272
3273	void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
3274	{
3275	return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
3276	}
3277
3278	#if defined( VK_USE_PLATFORM_WIN32_KHR )
3279	//=== VK_KHR_external_semaphore_win32 ===
3280
3281
3282	VkResult vkImportSemaphoreWin32HandleKHR( VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
3283	{
3284	return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo );
3285	}
3286
3287
3288	VkResult vkGetSemaphoreWin32HandleKHR( VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
3289	{
3290	return ::vkGetSemaphoreWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
3291	}
3292	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
3293
3294	//=== VK_KHR_external_semaphore_fd ===
3295
3296
3297	VkResult vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo ) const VULKAN_HPP_NOEXCEPT
3298	{
3299	return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo );
3300	}
3301
3302
3303	VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
3304	{
3305	return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd );
3306	}
3307
3308	//=== VK_KHR_push_descriptor ===
3309
3310
3311	void vkCmdPushDescriptorSetKHR( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet * pDescriptorWrites ) const VULKAN_HPP_NOEXCEPT
3312	{
3313	return ::vkCmdPushDescriptorSetKHR( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites );
3314	}
3315
3316
3317	void vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void * pData ) const VULKAN_HPP_NOEXCEPT
3318	{
3319	return ::vkCmdPushDescriptorSetWithTemplateKHR( commandBuffer, descriptorUpdateTemplate, layout, set, pData );
3320	}
3321
3322	//=== VK_EXT_conditional_rendering ===
3323
3324
3325	void vkCmdBeginConditionalRenderingEXT( VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT
3326	{
3327	return ::vkCmdBeginConditionalRenderingEXT( commandBuffer, pConditionalRenderingBegin );
3328	}
3329
3330
3331	void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
3332	{
3333	return ::vkCmdEndConditionalRenderingEXT( commandBuffer );
3334	}
3335
3336	//=== VK_KHR_descriptor_update_template ===
3337
3338
3339	VkResult vkCreateDescriptorUpdateTemplateKHR( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT
3340	{
3341	return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
3342	}
3343
3344
3345	void vkDestroyDescriptorUpdateTemplateKHR( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
3346	{
3347	return ::vkDestroyDescriptorUpdateTemplateKHR( device, descriptorUpdateTemplate, pAllocator );
3348	}
3349
3350
3351	void vkUpdateDescriptorSetWithTemplateKHR( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void * pData ) const VULKAN_HPP_NOEXCEPT
3352	{
3353	return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData );
3354	}
3355
3356	//=== VK_NV_clip_space_w_scaling ===
3357
3358
3359	void vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV * pViewportWScalings ) const VULKAN_HPP_NOEXCEPT
3360	{
3361	return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings );
3362	}
3363
3364	//=== VK_EXT_direct_mode_display ===
3365
3366
3367	VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
3368	{
3369	return ::vkReleaseDisplayEXT( physicalDevice, display );
3370	}
3371
3372	#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
3373	//=== VK_EXT_acquire_xlib_display ===
3374
3375
3376	VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
3377	{
3378	return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display );
3379	}
3380
3381
3382	VkResult vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, RROutput rrOutput, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT
3383	{
3384	return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay );
3385	}
3386	#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
3387
3388	//=== VK_EXT_display_surface_counter ===
3389
3390
3391	VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
3392	{
3393	return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities );
3394	}
3395
3396	//=== VK_EXT_display_control ===
3397
3398
3399	VkResult vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT * pDisplayPowerInfo ) const VULKAN_HPP_NOEXCEPT
3400	{
3401	return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo );
3402	}
3403
3404
3405	VkResult vkRegisterDeviceEventEXT( VkDevice device, const VkDeviceEventInfoEXT * pDeviceEventInfo, const VkAllocationCallbacks * pAllocator, VkFence * pFence ) const VULKAN_HPP_NOEXCEPT
3406	{
3407	return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence );
3408	}
3409
3410
3411	VkResult vkRegisterDisplayEventEXT( VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT * pDisplayEventInfo, const VkAllocationCallbacks * pAllocator, VkFence * pFence ) const VULKAN_HPP_NOEXCEPT
3412	{
3413	return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence );
3414	}
3415
3416
3417	VkResult vkGetSwapchainCounterEXT( VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t * pCounterValue ) const VULKAN_HPP_NOEXCEPT
3418	{
3419	return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue );
3420	}
3421
3422	//=== VK_GOOGLE_display_timing ===
3423
3424
3425	VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE * pDisplayTimingProperties ) const VULKAN_HPP_NOEXCEPT
3426	{
3427	return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties );
3428	}
3429
3430
3431	VkResult vkGetPastPresentationTimingGOOGLE( VkDevice device, VkSwapchainKHR swapchain, uint32_t * pPresentationTimingCount, VkPastPresentationTimingGOOGLE * pPresentationTimings ) const VULKAN_HPP_NOEXCEPT
3432	{
3433	return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings );
3434	}
3435
3436	//=== VK_EXT_discard_rectangles ===
3437
3438
3439	void vkCmdSetDiscardRectangleEXT( VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D * pDiscardRectangles ) const VULKAN_HPP_NOEXCEPT
3440	{
3441	return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles );
3442	}
3443
3444	//=== VK_EXT_hdr_metadata ===
3445
3446
3447	void vkSetHdrMetadataEXT( VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR * pSwapchains, const VkHdrMetadataEXT * pMetadata ) const VULKAN_HPP_NOEXCEPT
3448	{
3449	return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata );
3450	}
3451
3452	//=== VK_KHR_create_renderpass2 ===
3453
3454
3455	VkResult vkCreateRenderPass2KHR( VkDevice device, const VkRenderPassCreateInfo2 * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT
3456	{
3457	return ::vkCreateRenderPass2KHR( device, pCreateInfo, pAllocator, pRenderPass );
3458	}
3459
3460
3461	void vkCmdBeginRenderPass2KHR( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo * pRenderPassBegin, const VkSubpassBeginInfo * pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
3462	{
3463	return ::vkCmdBeginRenderPass2KHR( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
3464	}
3465
3466
3467	void vkCmdNextSubpass2KHR( VkCommandBuffer commandBuffer, const VkSubpassBeginInfo * pSubpassBeginInfo, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
3468	{
3469	return ::vkCmdNextSubpass2KHR( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
3470	}
3471
3472
3473	void vkCmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
3474	{
3475	return ::vkCmdEndRenderPass2KHR( commandBuffer, pSubpassEndInfo );
3476	}
3477
3478	//=== VK_KHR_shared_presentable_image ===
3479
3480
3481	VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
3482	{
3483	return ::vkGetSwapchainStatusKHR( device, swapchain );
3484	}
3485
3486	//=== VK_KHR_external_fence_capabilities ===
3487
3488
3489	void vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo, VkExternalFenceProperties * pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT
3490	{
3491	return ::vkGetPhysicalDeviceExternalFencePropertiesKHR( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
3492	}
3493
3494	#if defined( VK_USE_PLATFORM_WIN32_KHR )
3495	//=== VK_KHR_external_fence_win32 ===
3496
3497
3498	VkResult vkImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
3499	{
3500	return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo );
3501	}
3502
3503
3504	VkResult vkGetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
3505	{
3506	return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
3507	}
3508	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
3509
3510	//=== VK_KHR_external_fence_fd ===
3511
3512
3513	VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR * pImportFenceFdInfo ) const VULKAN_HPP_NOEXCEPT
3514	{
3515	return ::vkImportFenceFdKHR( device, pImportFenceFdInfo );
3516	}
3517
3518
3519	VkResult vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
3520	{
3521	return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd );
3522	}
3523
3524	//=== VK_KHR_performance_query ===
3525
3526
3527	VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t * pCounterCount, VkPerformanceCounterKHR * pCounters, VkPerformanceCounterDescriptionKHR * pCounterDescriptions ) const VULKAN_HPP_NOEXCEPT
3528	{
3529	return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions );
3530	}
3531
3532
3533	void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo, uint32_t * pNumPasses ) const VULKAN_HPP_NOEXCEPT
3534	{
3535	return ::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( physicalDevice, pPerformanceQueryCreateInfo, pNumPasses );
3536	}
3537
3538
3539	VkResult vkAcquireProfilingLockKHR( VkDevice device, const VkAcquireProfilingLockInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
3540	{
3541	return ::vkAcquireProfilingLockKHR( device, pInfo );
3542	}
3543
3544
3545	void vkReleaseProfilingLockKHR( VkDevice device ) const VULKAN_HPP_NOEXCEPT
3546	{
3547	return ::vkReleaseProfilingLockKHR( device );
3548	}
3549
3550	//=== VK_KHR_get_surface_capabilities2 ===
3551
3552
3553	VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, VkSurfaceCapabilities2KHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
3554	{
3555	return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities );
3556	}
3557
3558
3559	VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, uint32_t * pSurfaceFormatCount, VkSurfaceFormat2KHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT
3560	{
3561	return ::vkGetPhysicalDeviceSurfaceFormats2KHR( physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats );
3562	}
3563
3564	//=== VK_KHR_get_display_properties2 ===
3565
3566
3567	VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkDisplayProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
3568	{
3569	return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties );
3570	}
3571
3572
3573	VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkDisplayPlaneProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
3574	{
3575	return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties );
3576	}
3577
3578
3579	VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t * pPropertyCount, VkDisplayModeProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
3580	{
3581	return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties );
3582	}
3583
3584
3585	VkResult vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR * pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
3586	{
3587	return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities );
3588	}
3589
3590	#if defined( VK_USE_PLATFORM_IOS_MVK )
3591	//=== VK_MVK_ios_surface ===
3592
3593
3594	VkResult vkCreateIOSSurfaceMVK( VkInstance instance, const VkIOSSurfaceCreateInfoMVK * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
3595	{
3596	return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
3597	}
3598	#endif /*VK_USE_PLATFORM_IOS_MVK*/
3599
3600	#if defined( VK_USE_PLATFORM_MACOS_MVK )
3601	//=== VK_MVK_macos_surface ===
3602
3603
3604	VkResult vkCreateMacOSSurfaceMVK( VkInstance instance, const VkMacOSSurfaceCreateInfoMVK * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
3605	{
3606	return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
3607	}
3608	#endif /*VK_USE_PLATFORM_MACOS_MVK*/
3609
3610	//=== VK_EXT_debug_utils ===
3611
3612
3613	VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT
3614	{
3615	return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo );
3616	}
3617
3618
3619	VkResult vkSetDebugUtilsObjectTagEXT( VkDevice device, const VkDebugUtilsObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT
3620	{
3621	return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo );
3622	}
3623
3624
3625	void vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
3626	{
3627	return ::vkQueueBeginDebugUtilsLabelEXT( queue, pLabelInfo );
3628	}
3629
3630
3631	void vkQueueEndDebugUtilsLabelEXT( VkQueue queue ) const VULKAN_HPP_NOEXCEPT
3632	{
3633	return ::vkQueueEndDebugUtilsLabelEXT( queue );
3634	}
3635
3636
3637	void vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
3638	{
3639	return ::vkQueueInsertDebugUtilsLabelEXT( queue, pLabelInfo );
3640	}
3641
3642
3643	void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
3644	{
3645	return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
3646	}
3647
3648
3649	void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
3650	{
3651	return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer );
3652	}
3653
3654
3655	void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
3656	{
3657	return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
3658	}
3659
3660
3661	VkResult vkCreateDebugUtilsMessengerEXT( VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkDebugUtilsMessengerEXT * pMessenger ) const VULKAN_HPP_NOEXCEPT
3662	{
3663	return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger );
3664	}
3665
3666
3667	void vkDestroyDebugUtilsMessengerEXT( VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
3668	{
3669	return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator );
3670	}
3671
3672
3673	void vkSubmitDebugUtilsMessageEXT( VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData ) const VULKAN_HPP_NOEXCEPT
3674	{
3675	return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData );
3676	}
3677
3678	#if defined( VK_USE_PLATFORM_ANDROID_KHR )
3679	//=== VK_ANDROID_external_memory_android_hardware_buffer ===
3680
3681
3682	VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device, const struct AHardwareBuffer * buffer, VkAndroidHardwareBufferPropertiesANDROID * pProperties ) const VULKAN_HPP_NOEXCEPT
3683	{
3684	return ::vkGetAndroidHardwareBufferPropertiesANDROID( device, buffer, pProperties );
3685	}
3686
3687
3688	VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID * pInfo, struct AHardwareBuffer ** pBuffer ) const VULKAN_HPP_NOEXCEPT
3689	{
3690	return ::vkGetMemoryAndroidHardwareBufferANDROID( device, pInfo, pBuffer );
3691	}
3692	#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
3693
3694	//=== VK_EXT_sample_locations ===
3695
3696
3697	void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT * pSampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT
3698	{
3699	return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo );
3700	}
3701
3702
3703	void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT * pMultisampleProperties ) const VULKAN_HPP_NOEXCEPT
3704	{
3705	return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties );
3706	}
3707
3708	//=== VK_KHR_get_memory_requirements2 ===
3709
3710
3711	void vkGetImageMemoryRequirements2KHR( VkDevice device, const VkImageMemoryRequirementsInfo2 * pInfo, VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
3712	{
3713	return ::vkGetImageMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
3714	}
3715
3716
3717	void vkGetBufferMemoryRequirements2KHR( VkDevice device, const VkBufferMemoryRequirementsInfo2 * pInfo, VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
3718	{
3719	return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
3720	}
3721
3722
3723	void vkGetImageSparseMemoryRequirements2KHR( VkDevice device, const VkImageSparseMemoryRequirementsInfo2 * pInfo, uint32_t * pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
3724	{
3725	return ::vkGetImageSparseMemoryRequirements2KHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
3726	}
3727
3728	//=== VK_KHR_acceleration_structure ===
3729
3730
3731	VkResult vkCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkAccelerationStructureKHR * pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT
3732	{
3733	return ::vkCreateAccelerationStructureKHR( device, pCreateInfo, pAllocator, pAccelerationStructure );
3734	}
3735
3736
3737	void vkDestroyAccelerationStructureKHR( VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
3738	{
3739	return ::vkDestroyAccelerationStructureKHR( device, accelerationStructure, pAllocator );
3740	}
3741
3742
3743	void vkCmdBuildAccelerationStructuresKHR( VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR * pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT
3744	{
3745	return ::vkCmdBuildAccelerationStructuresKHR( commandBuffer, infoCount, pInfos, ppBuildRangeInfos );
3746	}
3747
3748
3749	void vkCmdBuildAccelerationStructuresIndirectKHR( VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR * pInfos, const VkDeviceAddress * pIndirectDeviceAddresses, const uint32_t * pIndirectStrides, const uint32_t * const * ppMaxPrimitiveCounts ) const VULKAN_HPP_NOEXCEPT
3750	{
3751	return ::vkCmdBuildAccelerationStructuresIndirectKHR( commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts );
3752	}
3753
3754
3755	VkResult vkBuildAccelerationStructuresKHR( VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR * pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT
3756	{
3757	return ::vkBuildAccelerationStructuresKHR( device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos );
3758	}
3759
3760
3761	VkResult vkCopyAccelerationStructureKHR( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
3762	{
3763	return ::vkCopyAccelerationStructureKHR( device, deferredOperation, pInfo );
3764	}
3765
3766
3767	VkResult vkCopyAccelerationStructureToMemoryKHR( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
3768	{
3769	return ::vkCopyAccelerationStructureToMemoryKHR( device, deferredOperation, pInfo );
3770	}
3771
3772
3773	VkResult vkCopyMemoryToAccelerationStructureKHR( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
3774	{
3775	return ::vkCopyMemoryToAccelerationStructureKHR( device, deferredOperation, pInfo );
3776	}
3777
3778
3779	VkResult vkWriteAccelerationStructuresPropertiesKHR( VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR * pAccelerationStructures, VkQueryType queryType, size_t dataSize, void * pData, size_t stride ) const VULKAN_HPP_NOEXCEPT
3780	{
3781	return ::vkWriteAccelerationStructuresPropertiesKHR( device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride );
3782	}
3783
3784
3785	void vkCmdCopyAccelerationStructureKHR( VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
3786	{
3787	return ::vkCmdCopyAccelerationStructureKHR( commandBuffer, pInfo );
3788	}
3789
3790
3791	void vkCmdCopyAccelerationStructureToMemoryKHR( VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
3792	{
3793	return ::vkCmdCopyAccelerationStructureToMemoryKHR( commandBuffer, pInfo );
3794	}
3795
3796
3797	void vkCmdCopyMemoryToAccelerationStructureKHR( VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
3798	{
3799	return ::vkCmdCopyMemoryToAccelerationStructureKHR( commandBuffer, pInfo );
3800	}
3801
3802
3803	VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR( VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
3804	{
3805	return ::vkGetAccelerationStructureDeviceAddressKHR( device, pInfo );
3806	}
3807
3808
3809	void vkCmdWriteAccelerationStructuresPropertiesKHR( VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR * pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
3810	{
3811	return ::vkCmdWriteAccelerationStructuresPropertiesKHR( commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery );
3812	}
3813
3814
3815	void vkGetDeviceAccelerationStructureCompatibilityKHR( VkDevice device, const VkAccelerationStructureVersionInfoKHR * pVersionInfo, VkAccelerationStructureCompatibilityKHR * pCompatibility ) const VULKAN_HPP_NOEXCEPT
3816	{
3817	return ::vkGetDeviceAccelerationStructureCompatibilityKHR( device, pVersionInfo, pCompatibility );
3818	}
3819
3820
3821	void vkGetAccelerationStructureBuildSizesKHR( VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR * pBuildInfo, const uint32_t * pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR * pSizeInfo ) const VULKAN_HPP_NOEXCEPT
3822	{
3823	return ::vkGetAccelerationStructureBuildSizesKHR( device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo );
3824	}
3825
3826	//=== VK_KHR_sampler_ycbcr_conversion ===
3827
3828
3829	VkResult vkCreateSamplerYcbcrConversionKHR( VkDevice device, const VkSamplerYcbcrConversionCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSamplerYcbcrConversion * pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
3830	{
3831	return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion );
3832	}
3833
3834
3835	void vkDestroySamplerYcbcrConversionKHR( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
3836	{
3837	return ::vkDestroySamplerYcbcrConversionKHR( device, ycbcrConversion, pAllocator );
3838	}
3839
3840	//=== VK_KHR_bind_memory2 ===
3841
3842
3843	VkResult vkBindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
3844	{
3845	return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos );
3846	}
3847
3848
3849	VkResult vkBindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
3850	{
3851	return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos );
3852	}
3853
3854	//=== VK_EXT_image_drm_format_modifier ===
3855
3856
3857	VkResult vkGetImageDrmFormatModifierPropertiesEXT( VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT * pProperties ) const VULKAN_HPP_NOEXCEPT
3858	{
3859	return ::vkGetImageDrmFormatModifierPropertiesEXT( device, image, pProperties );
3860	}
3861
3862	//=== VK_EXT_validation_cache ===
3863
3864
3865	VkResult vkCreateValidationCacheEXT( VkDevice device, const VkValidationCacheCreateInfoEXT * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkValidationCacheEXT * pValidationCache ) const VULKAN_HPP_NOEXCEPT
3866	{
3867	return ::vkCreateValidationCacheEXT( device, pCreateInfo, pAllocator, pValidationCache );
3868	}
3869
3870
3871	void vkDestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
3872	{
3873	return ::vkDestroyValidationCacheEXT( device, validationCache, pAllocator );
3874	}
3875
3876
3877	VkResult vkMergeValidationCachesEXT( VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
3878	{
3879	return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches );
3880	}
3881
3882
3883	VkResult vkGetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
3884	{
3885	return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData );
3886	}
3887
3888	//=== VK_NV_shading_rate_image ===
3889
3890
3891	void vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
3892	{
3893	return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout );
3894	}
3895
3896
3897	void vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV * pShadingRatePalettes ) const VULKAN_HPP_NOEXCEPT
3898	{
3899	return ::vkCmdSetViewportShadingRatePaletteNV( commandBuffer, firstViewport, viewportCount, pShadingRatePalettes );
3900	}
3901
3902
3903	void vkCmdSetCoarseSampleOrderNV( VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV * pCustomSampleOrders ) const VULKAN_HPP_NOEXCEPT
3904	{
3905	return ::vkCmdSetCoarseSampleOrderNV( commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders );
3906	}
3907
3908	//=== VK_NV_ray_tracing ===
3909
3910
3911	VkResult vkCreateAccelerationStructureNV( VkDevice device, const VkAccelerationStructureCreateInfoNV * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkAccelerationStructureNV * pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT
3912	{
3913	return ::vkCreateAccelerationStructureNV( device, pCreateInfo, pAllocator, pAccelerationStructure );
3914	}
3915
3916
3917	void vkDestroyAccelerationStructureNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
3918	{
3919	return ::vkDestroyAccelerationStructureNV( device, accelerationStructure, pAllocator );
3920	}
3921
3922
3923	void vkGetAccelerationStructureMemoryRequirementsNV( VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV * pInfo, VkMemoryRequirements2KHR * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
3924	{
3925	return ::vkGetAccelerationStructureMemoryRequirementsNV( device, pInfo, pMemoryRequirements );
3926	}
3927
3928
3929	VkResult vkBindAccelerationStructureMemoryNV( VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV * pBindInfos ) const VULKAN_HPP_NOEXCEPT
3930	{
3931	return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos );
3932	}
3933
3934
3935	void vkCmdBuildAccelerationStructureNV( VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV * pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT
3936	{
3937	return ::vkCmdBuildAccelerationStructureNV( commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset );
3938	}
3939
3940
3941	void vkCmdCopyAccelerationStructureNV( VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT
3942	{
3943	return ::vkCmdCopyAccelerationStructureNV( commandBuffer, dst, src, mode );
3944	}
3945
3946
3947	void vkCmdTraceRaysNV( VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth ) const VULKAN_HPP_NOEXCEPT
3948	{
3949	return ::vkCmdTraceRaysNV( commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth );
3950	}
3951
3952
3953	VkResult vkCreateRayTracingPipelinesNV( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV * pCreateInfos, const VkAllocationCallbacks * pAllocator, VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
3954	{
3955	return ::vkCreateRayTracingPipelinesNV( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
3956	}
3957
3958
3959	VkResult vkGetRayTracingShaderGroupHandlesNV( VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
3960	{
3961	return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData );
3962	}
3963
3964
3965	VkResult vkGetAccelerationStructureHandleNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
3966	{
3967	return ::vkGetAccelerationStructureHandleNV( device, accelerationStructure, dataSize, pData );
3968	}
3969
3970
3971	void vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV * pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
3972	{
3973	return ::vkCmdWriteAccelerationStructuresPropertiesNV( commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery );
3974	}
3975
3976
3977	VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader ) const VULKAN_HPP_NOEXCEPT
3978	{
3979	return ::vkCompileDeferredNV( device, pipeline, shader );
3980	}
3981
3982	//=== VK_KHR_maintenance3 ===
3983
3984
3985	void vkGetDescriptorSetLayoutSupportKHR( VkDevice device, const VkDescriptorSetLayoutCreateInfo * pCreateInfo, VkDescriptorSetLayoutSupport * pSupport ) const VULKAN_HPP_NOEXCEPT
3986	{
3987	return ::vkGetDescriptorSetLayoutSupportKHR( device, pCreateInfo, pSupport );
3988	}
3989
3990	//=== VK_KHR_draw_indirect_count ===
3991
3992
3993	void vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
3994	{
3995	return ::vkCmdDrawIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
3996	}
3997
3998
3999	void vkCmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
4000	{
4001	return ::vkCmdDrawIndexedIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
4002	}
4003
4004	//=== VK_EXT_external_memory_host ===
4005
4006
4007	VkResult vkGetMemoryHostPointerPropertiesEXT( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer, VkMemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties ) const VULKAN_HPP_NOEXCEPT
4008	{
4009	return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties );
4010	}
4011
4012	//=== VK_AMD_buffer_marker ===
4013
4014
4015	void vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const VULKAN_HPP_NOEXCEPT
4016	{
4017	return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker );
4018	}
4019
4020	//=== VK_EXT_calibrated_timestamps ===
4021
4022
4023	VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice, uint32_t * pTimeDomainCount, VkTimeDomainEXT * pTimeDomains ) const VULKAN_HPP_NOEXCEPT
4024	{
4025	return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains );
4026	}
4027
4028
4029	VkResult vkGetCalibratedTimestampsEXT( VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT * pTimestampInfos, uint64_t * pTimestamps, uint64_t * pMaxDeviation ) const VULKAN_HPP_NOEXCEPT
4030	{
4031	return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation );
4032	}
4033
4034	//=== VK_NV_mesh_shader ===
4035
4036
4037	void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT
4038	{
4039	return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask );
4040	}
4041
4042
4043	void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
4044	{
4045	return ::vkCmdDrawMeshTasksIndirectNV( commandBuffer, buffer, offset, drawCount, stride );
4046	}
4047
4048
4049	void vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
4050	{
4051	return ::vkCmdDrawMeshTasksIndirectCountNV( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
4052	}
4053
4054	//=== VK_NV_scissor_exclusive ===
4055
4056
4057	void vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D * pExclusiveScissors ) const VULKAN_HPP_NOEXCEPT
4058	{
4059	return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors );
4060	}
4061
4062	//=== VK_NV_device_diagnostic_checkpoints ===
4063
4064
4065	void vkCmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT
4066	{
4067	return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker );
4068	}
4069
4070
4071	void vkGetQueueCheckpointDataNV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointDataNV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
4072	{
4073	return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData );
4074	}
4075
4076	//=== VK_KHR_timeline_semaphore ===
4077
4078
4079	VkResult vkGetSemaphoreCounterValueKHR( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
4080	{
4081	return ::vkGetSemaphoreCounterValueKHR( device, semaphore, pValue );
4082	}
4083
4084
4085	VkResult vkWaitSemaphoresKHR( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
4086	{
4087	return ::vkWaitSemaphoresKHR( device, pWaitInfo, timeout );
4088	}
4089
4090
4091	VkResult vkSignalSemaphoreKHR( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
4092	{
4093	return ::vkSignalSemaphoreKHR( device, pSignalInfo );
4094	}
4095
4096	//=== VK_INTEL_performance_query ===
4097
4098
4099	VkResult vkInitializePerformanceApiINTEL( VkDevice device, const VkInitializePerformanceApiInfoINTEL * pInitializeInfo ) const VULKAN_HPP_NOEXCEPT
4100	{
4101	return ::vkInitializePerformanceApiINTEL( device, pInitializeInfo );
4102	}
4103
4104
4105	void vkUninitializePerformanceApiINTEL( VkDevice device ) const VULKAN_HPP_NOEXCEPT
4106	{
4107	return ::vkUninitializePerformanceApiINTEL( device );
4108	}
4109
4110
4111	VkResult vkCmdSetPerformanceMarkerINTEL( VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
4112	{
4113	return ::vkCmdSetPerformanceMarkerINTEL( commandBuffer, pMarkerInfo );
4114	}
4115
4116
4117	VkResult vkCmdSetPerformanceStreamMarkerINTEL( VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
4118	{
4119	return ::vkCmdSetPerformanceStreamMarkerINTEL( commandBuffer, pMarkerInfo );
4120	}
4121
4122
4123	VkResult vkCmdSetPerformanceOverrideINTEL( VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL * pOverrideInfo ) const VULKAN_HPP_NOEXCEPT
4124	{
4125	return ::vkCmdSetPerformanceOverrideINTEL( commandBuffer, pOverrideInfo );
4126	}
4127
4128
4129	VkResult vkAcquirePerformanceConfigurationINTEL( VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL * pAcquireInfo, VkPerformanceConfigurationINTEL * pConfiguration ) const VULKAN_HPP_NOEXCEPT
4130	{
4131	return ::vkAcquirePerformanceConfigurationINTEL( device, pAcquireInfo, pConfiguration );
4132	}
4133
4134
4135	VkResult vkReleasePerformanceConfigurationINTEL( VkDevice device, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT
4136	{
4137	return ::vkReleasePerformanceConfigurationINTEL( device, configuration );
4138	}
4139
4140
4141	VkResult vkQueueSetPerformanceConfigurationINTEL( VkQueue queue, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT
4142	{
4143	return ::vkQueueSetPerformanceConfigurationINTEL( queue, configuration );
4144	}
4145
4146
4147	VkResult vkGetPerformanceParameterINTEL( VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL * pValue ) const VULKAN_HPP_NOEXCEPT
4148	{
4149	return ::vkGetPerformanceParameterINTEL( device, parameter, pValue );
4150	}
4151
4152	//=== VK_AMD_display_native_hdr ===
4153
4154
4155	void vkSetLocalDimmingAMD( VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT
4156	{
4157	return ::vkSetLocalDimmingAMD( device, swapChain, localDimmingEnable );
4158	}
4159
4160	#if defined( VK_USE_PLATFORM_FUCHSIA )
4161	//=== VK_FUCHSIA_imagepipe_surface ===
4162
4163
4164	VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
4165	{
4166	return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface );
4167	}
4168	#endif /*VK_USE_PLATFORM_FUCHSIA*/
4169
4170	#if defined( VK_USE_PLATFORM_METAL_EXT )
4171	//=== VK_EXT_metal_surface ===
4172
4173
4174	VkResult vkCreateMetalSurfaceEXT( VkInstance instance, const VkMetalSurfaceCreateInfoEXT * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
4175	{
4176	return ::vkCreateMetalSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
4177	}
4178	#endif /*VK_USE_PLATFORM_METAL_EXT*/
4179
4180	//=== VK_KHR_fragment_shading_rate ===
4181
4182
4183	VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR( VkPhysicalDevice physicalDevice, uint32_t * pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates ) const VULKAN_HPP_NOEXCEPT
4184	{
4185	return ::vkGetPhysicalDeviceFragmentShadingRatesKHR( physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates );
4186	}
4187
4188
4189	void vkCmdSetFragmentShadingRateKHR( VkCommandBuffer commandBuffer, const VkExtent2D * pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
4190	{
4191	return ::vkCmdSetFragmentShadingRateKHR( commandBuffer, pFragmentSize, combinerOps );
4192	}
4193
4194	//=== VK_EXT_buffer_device_address ===
4195
4196
4197	VkDeviceAddress vkGetBufferDeviceAddressEXT( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
4198	{
4199	return ::vkGetBufferDeviceAddressEXT( device, pInfo );
4200	}
4201
4202	//=== VK_EXT_tooling_info ===
4203
4204
4205	VkResult vkGetPhysicalDeviceToolPropertiesEXT( VkPhysicalDevice physicalDevice, uint32_t * pToolCount, VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT
4206	{
4207	return ::vkGetPhysicalDeviceToolPropertiesEXT( physicalDevice, pToolCount, pToolProperties );
4208	}
4209
4210	//=== VK_KHR_present_wait ===
4211
4212
4213	VkResult vkWaitForPresentKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
4214	{
4215	return ::vkWaitForPresentKHR( device, swapchain, presentId, timeout );
4216	}
4217
4218	//=== VK_NV_cooperative_matrix ===
4219
4220
4221	VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkCooperativeMatrixPropertiesNV * pProperties ) const VULKAN_HPP_NOEXCEPT
4222	{
4223	return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( physicalDevice, pPropertyCount, pProperties );
4224	}
4225
4226	//=== VK_NV_coverage_reduction_mode ===
4227
4228
4229	VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( VkPhysicalDevice physicalDevice, uint32_t * pCombinationCount, VkFramebufferMixedSamplesCombinationNV * pCombinations ) const VULKAN_HPP_NOEXCEPT
4230	{
4231	return ::vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( physicalDevice, pCombinationCount, pCombinations );
4232	}
4233
4234	#if defined( VK_USE_PLATFORM_WIN32_KHR )
4235	//=== VK_EXT_full_screen_exclusive ===
4236
4237
4238	VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, uint32_t * pPresentModeCount, VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT
4239	{
4240	return ::vkGetPhysicalDeviceSurfacePresentModes2EXT( physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes );
4241	}
4242
4243
4244	VkResult vkAcquireFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
4245	{
4246	return ::vkAcquireFullScreenExclusiveModeEXT( device, swapchain );
4247	}
4248
4249
4250	VkResult vkReleaseFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
4251	{
4252	return ::vkReleaseFullScreenExclusiveModeEXT( device, swapchain );
4253	}
4254
4255
4256	VkResult vkGetDeviceGroupSurfacePresentModes2EXT( VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR * pModes ) const VULKAN_HPP_NOEXCEPT
4257	{
4258	return ::vkGetDeviceGroupSurfacePresentModes2EXT( device, pSurfaceInfo, pModes );
4259	}
4260	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
4261
4262	//=== VK_EXT_headless_surface ===
4263
4264
4265	VkResult vkCreateHeadlessSurfaceEXT( VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
4266	{
4267	return ::vkCreateHeadlessSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
4268	}
4269
4270	//=== VK_KHR_buffer_device_address ===
4271
4272
4273	VkDeviceAddress vkGetBufferDeviceAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
4274	{
4275	return ::vkGetBufferDeviceAddressKHR( device, pInfo );
4276	}
4277
4278
4279	uint64_t vkGetBufferOpaqueCaptureAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
4280	{
4281	return ::vkGetBufferOpaqueCaptureAddressKHR( device, pInfo );
4282	}
4283
4284
4285	uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
4286	{
4287	return ::vkGetDeviceMemoryOpaqueCaptureAddressKHR( device, pInfo );
4288	}
4289
4290	//=== VK_EXT_line_rasterization ===
4291
4292
4293	void vkCmdSetLineStippleEXT( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
4294	{
4295	return ::vkCmdSetLineStippleEXT( commandBuffer, lineStippleFactor, lineStipplePattern );
4296	}
4297
4298	//=== VK_EXT_host_query_reset ===
4299
4300
4301	void vkResetQueryPoolEXT( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
4302	{
4303	return ::vkResetQueryPoolEXT( device, queryPool, firstQuery, queryCount );
4304	}
4305
4306	//=== VK_EXT_extended_dynamic_state ===
4307
4308
4309	void vkCmdSetCullModeEXT( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
4310	{
4311	return ::vkCmdSetCullModeEXT( commandBuffer, cullMode );
4312	}
4313
4314
4315	void vkCmdSetFrontFaceEXT( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
4316	{
4317	return ::vkCmdSetFrontFaceEXT( commandBuffer, frontFace );
4318	}
4319
4320
4321	void vkCmdSetPrimitiveTopologyEXT( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
4322	{
4323	return ::vkCmdSetPrimitiveTopologyEXT( commandBuffer, primitiveTopology );
4324	}
4325
4326
4327	void vkCmdSetViewportWithCountEXT( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
4328	{
4329	return ::vkCmdSetViewportWithCountEXT( commandBuffer, viewportCount, pViewports );
4330	}
4331
4332
4333	void vkCmdSetScissorWithCountEXT( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
4334	{
4335	return ::vkCmdSetScissorWithCountEXT( commandBuffer, scissorCount, pScissors );
4336	}
4337
4338
4339	void vkCmdBindVertexBuffers2EXT( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer * pBuffers, const VkDeviceSize * pOffsets, const VkDeviceSize * pSizes, const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT
4340	{
4341	return ::vkCmdBindVertexBuffers2EXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
4342	}
4343
4344
4345	void vkCmdSetDepthTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
4346	{
4347	return ::vkCmdSetDepthTestEnableEXT( commandBuffer, depthTestEnable );
4348	}
4349
4350
4351	void vkCmdSetDepthWriteEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
4352	{
4353	return ::vkCmdSetDepthWriteEnableEXT( commandBuffer, depthWriteEnable );
4354	}
4355
4356
4357	void vkCmdSetDepthCompareOpEXT( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
4358	{
4359	return ::vkCmdSetDepthCompareOpEXT( commandBuffer, depthCompareOp );
4360	}
4361
4362
4363	void vkCmdSetDepthBoundsTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
4364	{
4365	return ::vkCmdSetDepthBoundsTestEnableEXT( commandBuffer, depthBoundsTestEnable );
4366	}
4367
4368
4369	void vkCmdSetStencilTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
4370	{
4371	return ::vkCmdSetStencilTestEnableEXT( commandBuffer, stencilTestEnable );
4372	}
4373
4374
4375	void vkCmdSetStencilOpEXT( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp ) const VULKAN_HPP_NOEXCEPT
4376	{
4377	return ::vkCmdSetStencilOpEXT( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
4378	}
4379
4380	//=== VK_KHR_deferred_host_operations ===
4381
4382
4383	VkResult vkCreateDeferredOperationKHR( VkDevice device, const VkAllocationCallbacks * pAllocator, VkDeferredOperationKHR * pDeferredOperation ) const VULKAN_HPP_NOEXCEPT
4384	{
4385	return ::vkCreateDeferredOperationKHR( device, pAllocator, pDeferredOperation );
4386	}
4387
4388
4389	void vkDestroyDeferredOperationKHR( VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
4390	{
4391	return ::vkDestroyDeferredOperationKHR( device, operation, pAllocator );
4392	}
4393
4394
4395	uint32_t vkGetDeferredOperationMaxConcurrencyKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
4396	{
4397	return ::vkGetDeferredOperationMaxConcurrencyKHR( device, operation );
4398	}
4399
4400
4401	VkResult vkGetDeferredOperationResultKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
4402	{
4403	return ::vkGetDeferredOperationResultKHR( device, operation );
4404	}
4405
4406
4407	VkResult vkDeferredOperationJoinKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
4408	{
4409	return ::vkDeferredOperationJoinKHR( device, operation );
4410	}
4411
4412	//=== VK_KHR_pipeline_executable_properties ===
4413
4414
4415	VkResult vkGetPipelineExecutablePropertiesKHR( VkDevice device, const VkPipelineInfoKHR * pPipelineInfo, uint32_t * pExecutableCount, VkPipelineExecutablePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
4416	{
4417	return ::vkGetPipelineExecutablePropertiesKHR( device, pPipelineInfo, pExecutableCount, pProperties );
4418	}
4419
4420
4421	VkResult vkGetPipelineExecutableStatisticsKHR( VkDevice device, const VkPipelineExecutableInfoKHR * pExecutableInfo, uint32_t * pStatisticCount, VkPipelineExecutableStatisticKHR * pStatistics ) const VULKAN_HPP_NOEXCEPT
4422	{
4423	return ::vkGetPipelineExecutableStatisticsKHR( device, pExecutableInfo, pStatisticCount, pStatistics );
4424	}
4425
4426
4427	VkResult vkGetPipelineExecutableInternalRepresentationsKHR( VkDevice device, const VkPipelineExecutableInfoKHR * pExecutableInfo, uint32_t * pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR * pInternalRepresentations ) const VULKAN_HPP_NOEXCEPT
4428	{
4429	return ::vkGetPipelineExecutableInternalRepresentationsKHR( device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations );
4430	}
4431
4432	//=== VK_EXT_swapchain_maintenance1 ===
4433
4434
4435	VkResult vkReleaseSwapchainImagesEXT( VkDevice device, const VkReleaseSwapchainImagesInfoEXT * pReleaseInfo ) const VULKAN_HPP_NOEXCEPT
4436	{
4437	return ::vkReleaseSwapchainImagesEXT( device, pReleaseInfo );
4438	}
4439
4440	//=== VK_NV_device_generated_commands ===
4441
4442
4443	void vkGetGeneratedCommandsMemoryRequirementsNV( VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV * pInfo, VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
4444	{
4445	return ::vkGetGeneratedCommandsMemoryRequirementsNV( device, pInfo, pMemoryRequirements );
4446	}
4447
4448
4449	void vkCmdPreprocessGeneratedCommandsNV( VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
4450	{
4451	return ::vkCmdPreprocessGeneratedCommandsNV( commandBuffer, pGeneratedCommandsInfo );
4452	}
4453
4454
4455	void vkCmdExecuteGeneratedCommandsNV( VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
4456	{
4457	return ::vkCmdExecuteGeneratedCommandsNV( commandBuffer, isPreprocessed, pGeneratedCommandsInfo );
4458	}
4459
4460
4461	void vkCmdBindPipelineShaderGroupNV( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT
4462	{
4463	return ::vkCmdBindPipelineShaderGroupNV( commandBuffer, pipelineBindPoint, pipeline, groupIndex );
4464	}
4465
4466
4467	VkResult vkCreateIndirectCommandsLayoutNV( VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkIndirectCommandsLayoutNV * pIndirectCommandsLayout ) const VULKAN_HPP_NOEXCEPT
4468	{
4469	return ::vkCreateIndirectCommandsLayoutNV( device, pCreateInfo, pAllocator, pIndirectCommandsLayout );
4470	}
4471
4472
4473	void vkDestroyIndirectCommandsLayoutNV( VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
4474	{
4475	return ::vkDestroyIndirectCommandsLayoutNV( device, indirectCommandsLayout, pAllocator );
4476	}
4477
4478	//=== VK_EXT_acquire_drm_display ===
4479
4480
4481	VkResult vkAcquireDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
4482	{
4483	return ::vkAcquireDrmDisplayEXT( physicalDevice, drmFd, display );
4484	}
4485
4486
4487	VkResult vkGetDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR * display ) const VULKAN_HPP_NOEXCEPT
4488	{
4489	return ::vkGetDrmDisplayEXT( physicalDevice, drmFd, connectorId, display );
4490	}
4491
4492	//=== VK_EXT_private_data ===
4493
4494
4495	VkResult vkCreatePrivateDataSlotEXT( VkDevice device, const VkPrivateDataSlotCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkPrivateDataSlot * pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT
4496	{
4497	return ::vkCreatePrivateDataSlotEXT( device, pCreateInfo, pAllocator, pPrivateDataSlot );
4498	}
4499
4500
4501	void vkDestroyPrivateDataSlotEXT( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
4502	{
4503	return ::vkDestroyPrivateDataSlotEXT( device, privateDataSlot, pAllocator );
4504	}
4505
4506
4507	VkResult vkSetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const VULKAN_HPP_NOEXCEPT
4508	{
4509	return ::vkSetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, data );
4510	}
4511
4512
4513	void vkGetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const VULKAN_HPP_NOEXCEPT
4514	{
4515	return ::vkGetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, pData );
4516	}
4517
4518	#if defined( VK_ENABLE_BETA_EXTENSIONS )
4519	//=== VK_KHR_video_encode_queue ===
4520
4521
4522	void vkCmdEncodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR * pEncodeInfo ) const VULKAN_HPP_NOEXCEPT
4523	{
4524	return ::vkCmdEncodeVideoKHR( commandBuffer, pEncodeInfo );
4525	}
4526	#endif /*VK_ENABLE_BETA_EXTENSIONS*/
4527
4528	#if defined( VK_USE_PLATFORM_METAL_EXT )
4529	//=== VK_EXT_metal_objects ===
4530
4531
4532	void vkExportMetalObjectsEXT( VkDevice device, VkExportMetalObjectsInfoEXT * pMetalObjectsInfo ) const VULKAN_HPP_NOEXCEPT
4533	{
4534	return ::vkExportMetalObjectsEXT( device, pMetalObjectsInfo );
4535	}
4536	#endif /*VK_USE_PLATFORM_METAL_EXT*/
4537
4538	//=== VK_KHR_synchronization2 ===
4539
4540
4541	void vkCmdSetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
4542	{
4543	return ::vkCmdSetEvent2KHR( commandBuffer, event, pDependencyInfo );
4544	}
4545
4546
4547	void vkCmdResetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
4548	{
4549	return ::vkCmdResetEvent2KHR( commandBuffer, event, stageMask );
4550	}
4551
4552
4553	void vkCmdWaitEvents2KHR( VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent * pEvents, const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT
4554	{
4555	return ::vkCmdWaitEvents2KHR( commandBuffer, eventCount, pEvents, pDependencyInfos );
4556	}
4557
4558
4559	void vkCmdPipelineBarrier2KHR( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
4560	{
4561	return ::vkCmdPipelineBarrier2KHR( commandBuffer, pDependencyInfo );
4562	}
4563
4564
4565	void vkCmdWriteTimestamp2KHR( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
4566	{
4567	return ::vkCmdWriteTimestamp2KHR( commandBuffer, stage, queryPool, query );
4568	}
4569
4570
4571	VkResult vkQueueSubmit2KHR( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
4572	{
4573	return ::vkQueueSubmit2KHR( queue, submitCount, pSubmits, fence );
4574	}
4575
4576
4577	void vkCmdWriteBufferMarker2AMD( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const VULKAN_HPP_NOEXCEPT
4578	{
4579	return ::vkCmdWriteBufferMarker2AMD( commandBuffer, stage, dstBuffer, dstOffset, marker );
4580	}
4581
4582
4583	void vkGetQueueCheckpointData2NV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointData2NV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
4584	{
4585	return ::vkGetQueueCheckpointData2NV( queue, pCheckpointDataCount, pCheckpointData );
4586	}
4587
4588	//=== VK_EXT_descriptor_buffer ===
4589
4590
4591	void vkGetDescriptorSetLayoutSizeEXT( VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize * pLayoutSizeInBytes ) const VULKAN_HPP_NOEXCEPT
4592	{
4593	return ::vkGetDescriptorSetLayoutSizeEXT( device, layout, pLayoutSizeInBytes );
4594	}
4595
4596
4597	void vkGetDescriptorSetLayoutBindingOffsetEXT( VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize * pOffset ) const VULKAN_HPP_NOEXCEPT
4598	{
4599	return ::vkGetDescriptorSetLayoutBindingOffsetEXT( device, layout, binding, pOffset );
4600	}
4601
4602
4603	void vkGetDescriptorEXT( VkDevice device, const VkDescriptorGetInfoEXT * pDescriptorInfo, size_t dataSize, void * pDescriptor ) const VULKAN_HPP_NOEXCEPT
4604	{
4605	return ::vkGetDescriptorEXT( device, pDescriptorInfo, dataSize, pDescriptor );
4606	}
4607
4608
4609	void vkCmdBindDescriptorBuffersEXT( VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT * pBindingInfos ) const VULKAN_HPP_NOEXCEPT
4610	{
4611	return ::vkCmdBindDescriptorBuffersEXT( commandBuffer, bufferCount, pBindingInfos );
4612	}
4613
4614
4615	void vkCmdSetDescriptorBufferOffsetsEXT( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t * pBufferIndices, const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT
4616	{
4617	return ::vkCmdSetDescriptorBufferOffsetsEXT( commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets );
4618	}
4619
4620
4621	void vkCmdBindDescriptorBufferEmbeddedSamplersEXT( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set ) const VULKAN_HPP_NOEXCEPT
4622	{
4623	return ::vkCmdBindDescriptorBufferEmbeddedSamplersEXT( commandBuffer, pipelineBindPoint, layout, set );
4624	}
4625
4626
4627	VkResult vkGetBufferOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT
4628	{
4629	return ::vkGetBufferOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
4630	}
4631
4632
4633	VkResult vkGetImageOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkImageCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT
4634	{
4635	return ::vkGetImageOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
4636	}
4637
4638
4639	VkResult vkGetImageViewOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT
4640	{
4641	return ::vkGetImageViewOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
4642	}
4643
4644
4645	VkResult vkGetSamplerOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT
4646	{
4647	return ::vkGetSamplerOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
4648	}
4649
4650
4651	VkResult vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT
4652	{
4653	return ::vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
4654	}
4655
4656	//=== VK_NV_fragment_shading_rate_enums ===
4657
4658
4659	void vkCmdSetFragmentShadingRateEnumNV( VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
4660	{
4661	return ::vkCmdSetFragmentShadingRateEnumNV( commandBuffer, shadingRate, combinerOps );
4662	}
4663
4664	//=== VK_EXT_mesh_shader ===
4665
4666
4667	void vkCmdDrawMeshTasksEXT( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
4668	{
4669	return ::vkCmdDrawMeshTasksEXT( commandBuffer, groupCountX, groupCountY, groupCountZ );
4670	}
4671
4672
4673	void vkCmdDrawMeshTasksIndirectEXT( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
4674	{
4675	return ::vkCmdDrawMeshTasksIndirectEXT( commandBuffer, buffer, offset, drawCount, stride );
4676	}
4677
4678
4679	void vkCmdDrawMeshTasksIndirectCountEXT( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
4680	{
4681	return ::vkCmdDrawMeshTasksIndirectCountEXT( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
4682	}
4683
4684	//=== VK_KHR_copy_commands2 ===
4685
4686
4687	void vkCmdCopyBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
4688	{
4689	return ::vkCmdCopyBuffer2KHR( commandBuffer, pCopyBufferInfo );
4690	}
4691
4692
4693	void vkCmdCopyImage2KHR( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT
4694	{
4695	return ::vkCmdCopyImage2KHR( commandBuffer, pCopyImageInfo );
4696	}
4697
4698
4699	void vkCmdCopyBufferToImage2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
4700	{
4701	return ::vkCmdCopyBufferToImage2KHR( commandBuffer, pCopyBufferToImageInfo );
4702	}
4703
4704
4705	void vkCmdCopyImageToBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
4706	{
4707	return ::vkCmdCopyImageToBuffer2KHR( commandBuffer, pCopyImageToBufferInfo );
4708	}
4709
4710
4711	void vkCmdBlitImage2KHR( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT
4712	{
4713	return ::vkCmdBlitImage2KHR( commandBuffer, pBlitImageInfo );
4714	}
4715
4716
4717	void vkCmdResolveImage2KHR( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT
4718	{
4719	return ::vkCmdResolveImage2KHR( commandBuffer, pResolveImageInfo );
4720	}
4721
4722	//=== VK_EXT_image_compression_control ===
4723
4724
4725	void vkGetImageSubresourceLayout2EXT( VkDevice device, VkImage image, const VkImageSubresource2EXT * pSubresource, VkSubresourceLayout2EXT * pLayout ) const VULKAN_HPP_NOEXCEPT
4726	{
4727	return ::vkGetImageSubresourceLayout2EXT( device, image, pSubresource, pLayout );
4728	}
4729
4730	//=== VK_EXT_device_fault ===
4731
4732
4733	VkResult vkGetDeviceFaultInfoEXT( VkDevice device, VkDeviceFaultCountsEXT * pFaultCounts, VkDeviceFaultInfoEXT * pFaultInfo ) const VULKAN_HPP_NOEXCEPT
4734	{
4735	return ::vkGetDeviceFaultInfoEXT( device, pFaultCounts, pFaultInfo );
4736	}
4737
4738	#if defined( VK_USE_PLATFORM_WIN32_KHR )
4739	//=== VK_NV_acquire_winrt_display ===
4740
4741
4742	VkResult vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
4743	{
4744	return ::vkAcquireWinrtDisplayNV( physicalDevice, display );
4745	}
4746
4747
4748	VkResult vkGetWinrtDisplayNV( VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT
4749	{
4750	return ::vkGetWinrtDisplayNV( physicalDevice, deviceRelativeId, pDisplay );
4751	}
4752	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
4753
4754	#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
4755	//=== VK_EXT_directfb_surface ===
4756
4757
4758	VkResult vkCreateDirectFBSurfaceEXT( VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
4759	{
4760	return ::vkCreateDirectFBSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
4761	}
4762
4763
4764	VkBool32 vkGetPhysicalDeviceDirectFBPresentationSupportEXT( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB * dfb ) const VULKAN_HPP_NOEXCEPT
4765	{
4766	return ::vkGetPhysicalDeviceDirectFBPresentationSupportEXT( physicalDevice, queueFamilyIndex, dfb );
4767	}
4768	#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
4769
4770	//=== VK_KHR_ray_tracing_pipeline ===
4771
4772
4773	void vkCmdTraceRaysKHR( VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth ) const VULKAN_HPP_NOEXCEPT
4774	{
4775	return ::vkCmdTraceRaysKHR( commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth );
4776	}
4777
4778
4779	VkResult vkCreateRayTracingPipelinesKHR( VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR * pCreateInfos, const VkAllocationCallbacks * pAllocator, VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
4780	{
4781	return ::vkCreateRayTracingPipelinesKHR( device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
4782	}
4783
4784
4785	VkResult vkGetRayTracingShaderGroupHandlesKHR( VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
4786	{
4787	return ::vkGetRayTracingShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
4788	}
4789
4790
4791	VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
4792	{
4793	return ::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
4794	}
4795
4796
4797	void vkCmdTraceRaysIndirectKHR( VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
4798	{
4799	return ::vkCmdTraceRaysIndirectKHR( commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress );
4800	}
4801
4802
4803	VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR( VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT
4804	{
4805	return ::vkGetRayTracingShaderGroupStackSizeKHR( device, pipeline, group, groupShader );
4806	}
4807
4808
4809	void vkCmdSetRayTracingPipelineStackSizeKHR( VkCommandBuffer commandBuffer, uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT
4810	{
4811	return ::vkCmdSetRayTracingPipelineStackSizeKHR( commandBuffer, pipelineStackSize );
4812	}
4813
4814	//=== VK_EXT_vertex_input_dynamic_state ===
4815
4816
4817	void vkCmdSetVertexInputEXT( VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT * pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT * pVertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT
4818	{
4819	return ::vkCmdSetVertexInputEXT( commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions );
4820	}
4821
4822	#if defined( VK_USE_PLATFORM_FUCHSIA )
4823	//=== VK_FUCHSIA_external_memory ===
4824
4825
4826	VkResult vkGetMemoryZirconHandleFUCHSIA( VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, zx_handle_t * pZirconHandle ) const VULKAN_HPP_NOEXCEPT
4827	{
4828	return ::vkGetMemoryZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle );
4829	}
4830
4831
4832	VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties ) const VULKAN_HPP_NOEXCEPT
4833	{
4834	return ::vkGetMemoryZirconHandlePropertiesFUCHSIA( device, handleType, zirconHandle, pMemoryZirconHandleProperties );
4835	}
4836	#endif /*VK_USE_PLATFORM_FUCHSIA*/
4837
4838	#if defined( VK_USE_PLATFORM_FUCHSIA )
4839	//=== VK_FUCHSIA_external_semaphore ===
4840
4841
4842	VkResult vkImportSemaphoreZirconHandleFUCHSIA( VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo ) const VULKAN_HPP_NOEXCEPT
4843	{
4844	return ::vkImportSemaphoreZirconHandleFUCHSIA( device, pImportSemaphoreZirconHandleInfo );
4845	}
4846
4847
4848	VkResult vkGetSemaphoreZirconHandleFUCHSIA( VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, zx_handle_t * pZirconHandle ) const VULKAN_HPP_NOEXCEPT
4849	{
4850	return ::vkGetSemaphoreZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle );
4851	}
4852	#endif /*VK_USE_PLATFORM_FUCHSIA*/
4853
4854	#if defined( VK_USE_PLATFORM_FUCHSIA )
4855	//=== VK_FUCHSIA_buffer_collection ===
4856
4857
4858	VkResult vkCreateBufferCollectionFUCHSIA( VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkBufferCollectionFUCHSIA * pCollection ) const VULKAN_HPP_NOEXCEPT
4859	{
4860	return ::vkCreateBufferCollectionFUCHSIA( device, pCreateInfo, pAllocator, pCollection );
4861	}
4862
4863
4864	VkResult vkSetBufferCollectionImageConstraintsFUCHSIA( VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA * pImageConstraintsInfo ) const VULKAN_HPP_NOEXCEPT
4865	{
4866	return ::vkSetBufferCollectionImageConstraintsFUCHSIA( device, collection, pImageConstraintsInfo );
4867	}
4868
4869
4870	VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA( VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo ) const VULKAN_HPP_NOEXCEPT
4871	{
4872	return ::vkSetBufferCollectionBufferConstraintsFUCHSIA( device, collection, pBufferConstraintsInfo );
4873	}
4874
4875
4876	void vkDestroyBufferCollectionFUCHSIA( VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
4877	{
4878	return ::vkDestroyBufferCollectionFUCHSIA( device, collection, pAllocator );
4879	}
4880
4881
4882	VkResult vkGetBufferCollectionPropertiesFUCHSIA( VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA * pProperties ) const VULKAN_HPP_NOEXCEPT
4883	{
4884	return ::vkGetBufferCollectionPropertiesFUCHSIA( device, collection, pProperties );
4885	}
4886	#endif /*VK_USE_PLATFORM_FUCHSIA*/
4887
4888	//=== VK_HUAWEI_subpass_shading ===
4889
4890
4891	VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( VkDevice device, VkRenderPass renderpass, VkExtent2D * pMaxWorkgroupSize ) const VULKAN_HPP_NOEXCEPT
4892	{
4893	return ::vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( device, renderpass, pMaxWorkgroupSize );
4894	}
4895
4896
4897	void vkCmdSubpassShadingHUAWEI( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
4898	{
4899	return ::vkCmdSubpassShadingHUAWEI( commandBuffer );
4900	}
4901
4902	//=== VK_HUAWEI_invocation_mask ===
4903
4904
4905	void vkCmdBindInvocationMaskHUAWEI( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
4906	{
4907	return ::vkCmdBindInvocationMaskHUAWEI( commandBuffer, imageView, imageLayout );
4908	}
4909
4910	//=== VK_NV_external_memory_rdma ===
4911
4912
4913	VkResult vkGetMemoryRemoteAddressNV( VkDevice device, const VkMemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo, VkRemoteAddressNV * pAddress ) const VULKAN_HPP_NOEXCEPT
4914	{
4915	return ::vkGetMemoryRemoteAddressNV( device, pMemoryGetRemoteAddressInfo, pAddress );
4916	}
4917
4918	//=== VK_EXT_pipeline_properties ===
4919
4920
4921	VkResult vkGetPipelinePropertiesEXT( VkDevice device, const VkPipelineInfoEXT * pPipelineInfo, VkBaseOutStructure * pPipelineProperties ) const VULKAN_HPP_NOEXCEPT
4922	{
4923	return ::vkGetPipelinePropertiesEXT( device, pPipelineInfo, pPipelineProperties );
4924	}
4925
4926	//=== VK_EXT_extended_dynamic_state2 ===
4927
4928
4929	void vkCmdSetPatchControlPointsEXT( VkCommandBuffer commandBuffer, uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT
4930	{
4931	return ::vkCmdSetPatchControlPointsEXT( commandBuffer, patchControlPoints );
4932	}
4933
4934
4935	void vkCmdSetRasterizerDiscardEnableEXT( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
4936	{
4937	return ::vkCmdSetRasterizerDiscardEnableEXT( commandBuffer, rasterizerDiscardEnable );
4938	}
4939
4940
4941	void vkCmdSetDepthBiasEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
4942	{
4943	return ::vkCmdSetDepthBiasEnableEXT( commandBuffer, depthBiasEnable );
4944	}
4945
4946
4947	void vkCmdSetLogicOpEXT( VkCommandBuffer commandBuffer, VkLogicOp logicOp ) const VULKAN_HPP_NOEXCEPT
4948	{
4949	return ::vkCmdSetLogicOpEXT( commandBuffer, logicOp );
4950	}
4951
4952
4953	void vkCmdSetPrimitiveRestartEnableEXT( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
4954	{
4955	return ::vkCmdSetPrimitiveRestartEnableEXT( commandBuffer, primitiveRestartEnable );
4956	}
4957
4958	#if defined( VK_USE_PLATFORM_SCREEN_QNX )
4959	//=== VK_QNX_screen_surface ===
4960
4961
4962	VkResult vkCreateScreenSurfaceQNX( VkInstance instance, const VkScreenSurfaceCreateInfoQNX * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
4963	{
4964	return ::vkCreateScreenSurfaceQNX( instance, pCreateInfo, pAllocator, pSurface );
4965	}
4966
4967
4968	VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window * window ) const VULKAN_HPP_NOEXCEPT
4969	{
4970	return ::vkGetPhysicalDeviceScreenPresentationSupportQNX( physicalDevice, queueFamilyIndex, window );
4971	}
4972	#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
4973
4974	//=== VK_EXT_color_write_enable ===
4975
4976
4977	void vkCmdSetColorWriteEnableEXT( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 * pColorWriteEnables ) const VULKAN_HPP_NOEXCEPT
4978	{
4979	return ::vkCmdSetColorWriteEnableEXT( commandBuffer, attachmentCount, pColorWriteEnables );
4980	}
4981
4982	//=== VK_KHR_ray_tracing_maintenance1 ===
4983
4984
4985	void vkCmdTraceRaysIndirect2KHR( VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
4986	{
4987	return ::vkCmdTraceRaysIndirect2KHR( commandBuffer, indirectDeviceAddress );
4988	}
4989
4990	//=== VK_EXT_multi_draw ===
4991
4992
4993	void vkCmdDrawMultiEXT( VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT * pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
4994	{
4995	return ::vkCmdDrawMultiEXT( commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride );
4996	}
4997
4998
4999	void vkCmdDrawMultiIndexedEXT( VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT * pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t * pVertexOffset ) const VULKAN_HPP_NOEXCEPT
5000	{
5001	return ::vkCmdDrawMultiIndexedEXT( commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset );
5002	}
5003
5004	//=== VK_EXT_opacity_micromap ===
5005
5006
5007	VkResult vkCreateMicromapEXT( VkDevice device, const VkMicromapCreateInfoEXT * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkMicromapEXT * pMicromap ) const VULKAN_HPP_NOEXCEPT
5008	{
5009	return ::vkCreateMicromapEXT( device, pCreateInfo, pAllocator, pMicromap );
5010	}
5011
5012
5013	void vkDestroyMicromapEXT( VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
5014	{
5015	return ::vkDestroyMicromapEXT( device, micromap, pAllocator );
5016	}
5017
5018
5019	void vkCmdBuildMicromapsEXT( VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT * pInfos ) const VULKAN_HPP_NOEXCEPT
5020	{
5021	return ::vkCmdBuildMicromapsEXT( commandBuffer, infoCount, pInfos );
5022	}
5023
5024
5025	VkResult vkBuildMicromapsEXT( VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT * pInfos ) const VULKAN_HPP_NOEXCEPT
5026	{
5027	return ::vkBuildMicromapsEXT( device, deferredOperation, infoCount, pInfos );
5028	}
5029
5030
5031	VkResult vkCopyMicromapEXT( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
5032	{
5033	return ::vkCopyMicromapEXT( device, deferredOperation, pInfo );
5034	}
5035
5036
5037	VkResult vkCopyMicromapToMemoryEXT( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
5038	{
5039	return ::vkCopyMicromapToMemoryEXT( device, deferredOperation, pInfo );
5040	}
5041
5042
5043	VkResult vkCopyMemoryToMicromapEXT( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
5044	{
5045	return ::vkCopyMemoryToMicromapEXT( device, deferredOperation, pInfo );
5046	}
5047
5048
5049	VkResult vkWriteMicromapsPropertiesEXT( VkDevice device, uint32_t micromapCount, const VkMicromapEXT * pMicromaps, VkQueryType queryType, size_t dataSize, void * pData, size_t stride ) const VULKAN_HPP_NOEXCEPT
5050	{
5051	return ::vkWriteMicromapsPropertiesEXT( device, micromapCount, pMicromaps, queryType, dataSize, pData, stride );
5052	}
5053
5054
5055	void vkCmdCopyMicromapEXT( VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
5056	{
5057	return ::vkCmdCopyMicromapEXT( commandBuffer, pInfo );
5058	}
5059
5060
5061	void vkCmdCopyMicromapToMemoryEXT( VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
5062	{
5063	return ::vkCmdCopyMicromapToMemoryEXT( commandBuffer, pInfo );
5064	}
5065
5066
5067	void vkCmdCopyMemoryToMicromapEXT( VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
5068	{
5069	return ::vkCmdCopyMemoryToMicromapEXT( commandBuffer, pInfo );
5070	}
5071
5072
5073	void vkCmdWriteMicromapsPropertiesEXT( VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT * pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
5074	{
5075	return ::vkCmdWriteMicromapsPropertiesEXT( commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery );
5076	}
5077
5078
5079	void vkGetDeviceMicromapCompatibilityEXT( VkDevice device, const VkMicromapVersionInfoEXT * pVersionInfo, VkAccelerationStructureCompatibilityKHR * pCompatibility ) const VULKAN_HPP_NOEXCEPT
5080	{
5081	return ::vkGetDeviceMicromapCompatibilityEXT( device, pVersionInfo, pCompatibility );
5082	}
5083
5084
5085	void vkGetMicromapBuildSizesEXT( VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT * pBuildInfo, VkMicromapBuildSizesInfoEXT * pSizeInfo ) const VULKAN_HPP_NOEXCEPT
5086	{
5087	return ::vkGetMicromapBuildSizesEXT( device, buildType, pBuildInfo, pSizeInfo );
5088	}
5089
5090	//=== VK_EXT_pageable_device_local_memory ===
5091
5092
5093	void vkSetDeviceMemoryPriorityEXT( VkDevice device, VkDeviceMemory memory, float priority ) const VULKAN_HPP_NOEXCEPT
5094	{
5095	return ::vkSetDeviceMemoryPriorityEXT( device, memory, priority );
5096	}
5097
5098	//=== VK_KHR_maintenance4 ===
5099
5100
5101	void vkGetDeviceBufferMemoryRequirementsKHR( VkDevice device, const VkDeviceBufferMemoryRequirements * pInfo, VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
5102	{
5103	return ::vkGetDeviceBufferMemoryRequirementsKHR( device, pInfo, pMemoryRequirements );
5104	}
5105
5106
5107	void vkGetDeviceImageMemoryRequirementsKHR( VkDevice device, const VkDeviceImageMemoryRequirements * pInfo, VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
5108	{
5109	return ::vkGetDeviceImageMemoryRequirementsKHR( device, pInfo, pMemoryRequirements );
5110	}
5111
5112
5113	void vkGetDeviceImageSparseMemoryRequirementsKHR( VkDevice device, const VkDeviceImageMemoryRequirements * pInfo, uint32_t * pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
5114	{
5115	return ::vkGetDeviceImageSparseMemoryRequirementsKHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
5116	}
5117
5118	//=== VK_VALVE_descriptor_set_host_mapping ===
5119
5120
5121	void vkGetDescriptorSetLayoutHostMappingInfoVALVE( VkDevice device, const VkDescriptorSetBindingReferenceVALVE * pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE * pHostMapping ) const VULKAN_HPP_NOEXCEPT
5122	{
5123	return ::vkGetDescriptorSetLayoutHostMappingInfoVALVE( device, pBindingReference, pHostMapping );
5124	}
5125
5126
5127	void vkGetDescriptorSetHostMappingVALVE( VkDevice device, VkDescriptorSet descriptorSet, void ** ppData ) const VULKAN_HPP_NOEXCEPT
5128	{
5129	return ::vkGetDescriptorSetHostMappingVALVE( device, descriptorSet, ppData );
5130	}
5131
5132	//=== VK_NV_copy_memory_indirect ===
5133
5134
5135	void vkCmdCopyMemoryIndirectNV( VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
5136	{
5137	return ::vkCmdCopyMemoryIndirectNV( commandBuffer, copyBufferAddress, copyCount, stride );
5138	}
5139
5140
5141	void vkCmdCopyMemoryToImageIndirectNV( VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers * pImageSubresources ) const VULKAN_HPP_NOEXCEPT
5142	{
5143	return ::vkCmdCopyMemoryToImageIndirectNV( commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources );
5144	}
5145
5146	//=== VK_NV_memory_decompression ===
5147
5148
5149	void vkCmdDecompressMemoryNV( VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV * pDecompressMemoryRegions ) const VULKAN_HPP_NOEXCEPT
5150	{
5151	return ::vkCmdDecompressMemoryNV( commandBuffer, decompressRegionCount, pDecompressMemoryRegions );
5152	}
5153
5154
5155	void vkCmdDecompressMemoryIndirectCountNV( VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
5156	{
5157	return ::vkCmdDecompressMemoryIndirectCountNV( commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride );
5158	}
5159
5160	//=== VK_EXT_extended_dynamic_state3 ===
5161
5162
5163	void vkCmdSetTessellationDomainOriginEXT( VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT
5164	{
5165	return ::vkCmdSetTessellationDomainOriginEXT( commandBuffer, domainOrigin );
5166	}
5167
5168
5169	void vkCmdSetDepthClampEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT
5170	{
5171	return ::vkCmdSetDepthClampEnableEXT( commandBuffer, depthClampEnable );
5172	}
5173
5174
5175	void vkCmdSetPolygonModeEXT( VkCommandBuffer commandBuffer, VkPolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT
5176	{
5177	return ::vkCmdSetPolygonModeEXT( commandBuffer, polygonMode );
5178	}
5179
5180
5181	void vkCmdSetRasterizationSamplesEXT( VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT
5182	{
5183	return ::vkCmdSetRasterizationSamplesEXT( commandBuffer, rasterizationSamples );
5184	}
5185
5186
5187	void vkCmdSetSampleMaskEXT( VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask * pSampleMask ) const VULKAN_HPP_NOEXCEPT
5188	{
5189	return ::vkCmdSetSampleMaskEXT( commandBuffer, samples, pSampleMask );
5190	}
5191
5192
5193	void vkCmdSetAlphaToCoverageEnableEXT( VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT
5194	{
5195	return ::vkCmdSetAlphaToCoverageEnableEXT( commandBuffer, alphaToCoverageEnable );
5196	}
5197
5198
5199	void vkCmdSetAlphaToOneEnableEXT( VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT
5200	{
5201	return ::vkCmdSetAlphaToOneEnableEXT( commandBuffer, alphaToOneEnable );
5202	}
5203
5204
5205	void vkCmdSetLogicOpEnableEXT( VkCommandBuffer commandBuffer, VkBool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT
5206	{
5207	return ::vkCmdSetLogicOpEnableEXT( commandBuffer, logicOpEnable );
5208	}
5209
5210
5211	void vkCmdSetColorBlendEnableEXT( VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32 * pColorBlendEnables ) const VULKAN_HPP_NOEXCEPT
5212	{
5213	return ::vkCmdSetColorBlendEnableEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables );
5214	}
5215
5216
5217	void vkCmdSetColorBlendEquationEXT( VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT * pColorBlendEquations ) const VULKAN_HPP_NOEXCEPT
5218	{
5219	return ::vkCmdSetColorBlendEquationEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations );
5220	}
5221
5222
5223	void vkCmdSetColorWriteMaskEXT( VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags * pColorWriteMasks ) const VULKAN_HPP_NOEXCEPT
5224	{
5225	return ::vkCmdSetColorWriteMaskEXT( commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks );
5226	}
5227
5228
5229	void vkCmdSetRasterizationStreamEXT( VkCommandBuffer commandBuffer, uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT
5230	{
5231	return ::vkCmdSetRasterizationStreamEXT( commandBuffer, rasterizationStream );
5232	}
5233
5234
5235	void vkCmdSetConservativeRasterizationModeEXT( VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode ) const VULKAN_HPP_NOEXCEPT
5236	{
5237	return ::vkCmdSetConservativeRasterizationModeEXT( commandBuffer, conservativeRasterizationMode );
5238	}
5239
5240
5241	void vkCmdSetExtraPrimitiveOverestimationSizeEXT( VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT
5242	{
5243	return ::vkCmdSetExtraPrimitiveOverestimationSizeEXT( commandBuffer, extraPrimitiveOverestimationSize );
5244	}
5245
5246
5247	void vkCmdSetDepthClipEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT
5248	{
5249	return ::vkCmdSetDepthClipEnableEXT( commandBuffer, depthClipEnable );
5250	}
5251
5252
5253	void vkCmdSetSampleLocationsEnableEXT( VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT
5254	{
5255	return ::vkCmdSetSampleLocationsEnableEXT( commandBuffer, sampleLocationsEnable );
5256	}
5257
5258
5259	void vkCmdSetColorBlendAdvancedEXT( VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT * pColorBlendAdvanced ) const VULKAN_HPP_NOEXCEPT
5260	{
5261	return ::vkCmdSetColorBlendAdvancedEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced );
5262	}
5263
5264
5265	void vkCmdSetProvokingVertexModeEXT( VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT
5266	{
5267	return ::vkCmdSetProvokingVertexModeEXT( commandBuffer, provokingVertexMode );
5268	}
5269
5270
5271	void vkCmdSetLineRasterizationModeEXT( VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT
5272	{
5273	return ::vkCmdSetLineRasterizationModeEXT( commandBuffer, lineRasterizationMode );
5274	}
5275
5276
5277	void vkCmdSetLineStippleEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT
5278	{
5279	return ::vkCmdSetLineStippleEnableEXT( commandBuffer, stippledLineEnable );
5280	}
5281
5282
5283	void vkCmdSetDepthClipNegativeOneToOneEXT( VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT
5284	{
5285	return ::vkCmdSetDepthClipNegativeOneToOneEXT( commandBuffer, negativeOneToOne );
5286	}
5287
5288
5289	void vkCmdSetViewportWScalingEnableNV( VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT
5290	{
5291	return ::vkCmdSetViewportWScalingEnableNV( commandBuffer, viewportWScalingEnable );
5292	}
5293
5294
5295	void vkCmdSetViewportSwizzleNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV * pViewportSwizzles ) const VULKAN_HPP_NOEXCEPT
5296	{
5297	return ::vkCmdSetViewportSwizzleNV( commandBuffer, firstViewport, viewportCount, pViewportSwizzles );
5298	}
5299
5300
5301	void vkCmdSetCoverageToColorEnableNV( VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT
5302	{
5303	return ::vkCmdSetCoverageToColorEnableNV( commandBuffer, coverageToColorEnable );
5304	}
5305
5306
5307	void vkCmdSetCoverageToColorLocationNV( VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT
5308	{
5309	return ::vkCmdSetCoverageToColorLocationNV( commandBuffer, coverageToColorLocation );
5310	}
5311
5312
5313	void vkCmdSetCoverageModulationModeNV( VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT
5314	{
5315	return ::vkCmdSetCoverageModulationModeNV( commandBuffer, coverageModulationMode );
5316	}
5317
5318
5319	void vkCmdSetCoverageModulationTableEnableNV( VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT
5320	{
5321	return ::vkCmdSetCoverageModulationTableEnableNV( commandBuffer, coverageModulationTableEnable );
5322	}
5323
5324
5325	void vkCmdSetCoverageModulationTableNV( VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float * pCoverageModulationTable ) const VULKAN_HPP_NOEXCEPT
5326	{
5327	return ::vkCmdSetCoverageModulationTableNV( commandBuffer, coverageModulationTableCount, pCoverageModulationTable );
5328	}
5329
5330
5331	void vkCmdSetShadingRateImageEnableNV( VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT
5332	{
5333	return ::vkCmdSetShadingRateImageEnableNV( commandBuffer, shadingRateImageEnable );
5334	}
5335
5336
5337	void vkCmdSetRepresentativeFragmentTestEnableNV( VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT
5338	{
5339	return ::vkCmdSetRepresentativeFragmentTestEnableNV( commandBuffer, representativeFragmentTestEnable );
5340	}
5341
5342
5343	void vkCmdSetCoverageReductionModeNV( VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT
5344	{
5345	return ::vkCmdSetCoverageReductionModeNV( commandBuffer, coverageReductionMode );
5346	}
5347
5348	//=== VK_EXT_shader_module_identifier ===
5349
5350
5351	void vkGetShaderModuleIdentifierEXT( VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT * pIdentifier ) const VULKAN_HPP_NOEXCEPT
5352	{
5353	return ::vkGetShaderModuleIdentifierEXT( device, shaderModule, pIdentifier );
5354	}
5355
5356
5357	void vkGetShaderModuleCreateInfoIdentifierEXT( VkDevice device, const VkShaderModuleCreateInfo * pCreateInfo, VkShaderModuleIdentifierEXT * pIdentifier ) const VULKAN_HPP_NOEXCEPT
5358	{
5359	return ::vkGetShaderModuleCreateInfoIdentifierEXT( device, pCreateInfo, pIdentifier );
5360	}
5361
5362	//=== VK_NV_optical_flow ===
5363
5364
5365	VkResult vkGetPhysicalDeviceOpticalFlowImageFormatsNV( VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo, uint32_t * pFormatCount, VkOpticalFlowImageFormatPropertiesNV * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
5366	{
5367	return ::vkGetPhysicalDeviceOpticalFlowImageFormatsNV( physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties );
5368	}
5369
5370
5371	VkResult vkCreateOpticalFlowSessionNV( VkDevice device, const VkOpticalFlowSessionCreateInfoNV * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkOpticalFlowSessionNV * pSession ) const VULKAN_HPP_NOEXCEPT
5372	{
5373	return ::vkCreateOpticalFlowSessionNV( device, pCreateInfo, pAllocator, pSession );
5374	}
5375
5376
5377	void vkDestroyOpticalFlowSessionNV( VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
5378	{
5379	return ::vkDestroyOpticalFlowSessionNV( device, session, pAllocator );
5380	}
5381
5382
5383	VkResult vkBindOpticalFlowSessionImageNV( VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout ) const VULKAN_HPP_NOEXCEPT
5384	{
5385	return ::vkBindOpticalFlowSessionImageNV( device, session, bindingPoint, view, layout );
5386	}
5387
5388
5389	void vkCmdOpticalFlowExecuteNV( VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV * pExecuteInfo ) const VULKAN_HPP_NOEXCEPT
5390	{
5391	return ::vkCmdOpticalFlowExecuteNV( commandBuffer, session, pExecuteInfo );
5392	}
5393
5394	//=== VK_QCOM_tile_properties ===
5395
5396
5397	VkResult vkGetFramebufferTilePropertiesQCOM( VkDevice device, VkFramebuffer framebuffer, uint32_t * pPropertiesCount, VkTilePropertiesQCOM * pProperties ) const VULKAN_HPP_NOEXCEPT
5398	{
5399	return ::vkGetFramebufferTilePropertiesQCOM( device, framebuffer, pPropertiesCount, pProperties );
5400	}
5401
5402
5403	VkResult vkGetDynamicRenderingTilePropertiesQCOM( VkDevice device, const VkRenderingInfo * pRenderingInfo, VkTilePropertiesQCOM * pProperties ) const VULKAN_HPP_NOEXCEPT
5404	{
5405	return ::vkGetDynamicRenderingTilePropertiesQCOM( device, pRenderingInfo, pProperties );
5406	}
5407
5408	};
5409	#endif
5410
5411	class DispatchLoaderDynamic;
5412	#if !defined(VULKAN_HPP_DISPATCH_LOADER_DYNAMIC)
5413	# if defined( VK_NO_PROTOTYPES )
5414	# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
5415	# else
5416	# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 0
5417	# endif
5418	#endif
5419
5420	#if !defined( VULKAN_HPP_STORAGE_API )
5421	# if defined( VULKAN_HPP_STORAGE_SHARED )
5422	# if defined( _MSC_VER )
5423	# if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT )
5424	# define VULKAN_HPP_STORAGE_API __declspec( dllexport )
5425	# else
5426	# define VULKAN_HPP_STORAGE_API __declspec( dllimport )
5427	# endif
5428	# elif defined( __clang__ ) || defined( __GNUC__ )
5429	# if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT )
5430	# define VULKAN_HPP_STORAGE_API __attribute__( ( visibility( "default" ) ) )
5431	# else
5432	# define VULKAN_HPP_STORAGE_API
5433	# endif
5434	# else
5435	# define VULKAN_HPP_STORAGE_API
5436	# pragma warning Unknown import / export semantics
5437	# endif
5438	# else
5439	# define VULKAN_HPP_STORAGE_API
5440	# endif
5441	#endif
5442
5443	#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER )
5444	# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
5445	# define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::defaultDispatchLoaderDynamic
5446	# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE \
5447	namespace VULKAN_HPP_NAMESPACE \
5448	{ \
5449	VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
5450	}
5451	extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic;
5452	# else
5453	static inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic()
5454	{
5455	static ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic dls;
5456	return dls;
5457	}
5458	# define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::getDispatchLoaderStatic()
5459	# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
5460	# endif
5461	#endif
5462
5463	#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER_TYPE )
5464	# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
5465	# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic
5466	# else
5467	# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic
5468	# endif
5469	#endif
5470
5471	#if defined( VULKAN_HPP_NO_DEFAULT_DISPATCHER )
5472	# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
5473	# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
5474	# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
5475	#else
5476	# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT = {}
5477	# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT = nullptr
5478	# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT = VULKAN_HPP_DEFAULT_DISPATCHER
5479	#endif
5480
5481	#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
5482	struct AllocationCallbacks;
5483
5484	template <typename OwnerType, typename Dispatch>
5485	class ObjectDestroy
5486	{
5487	public:
5488	ObjectDestroy() = default;
5489
5490	ObjectDestroy( OwnerType owner,
5491	Optional<const AllocationCallbacks> allocationCallbacks
5492	VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5493	Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
5494	: m_owner( owner )
5495	, m_allocationCallbacks( allocationCallbacks )
5496	, m_dispatch( &dispatch )
5497	{}
5498
5499	OwnerType getOwner() const VULKAN_HPP_NOEXCEPT { return m_owner; }
5500	Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT { return m_allocationCallbacks; }
5501
5502	protected:
5503	template <typename T>
5504	void destroy(T t) VULKAN_HPP_NOEXCEPT
5505	{
5506	VULKAN_HPP_ASSERT( m_owner && m_dispatch );
5507	m_owner.destroy( t, m_allocationCallbacks, *m_dispatch );
5508	}
5509
5510	private:
5511	OwnerType m_owner = {};
5512	Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
5513	Dispatch const * m_dispatch = nullptr;
5514	};
5515
5516	class NoParent;
5517
5518	template <typename Dispatch>
5519	class ObjectDestroy<NoParent, Dispatch>
5520	{
5521	public:
5522	ObjectDestroy() = default;
5523
5524	ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks,
5525	Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
5526	: m_allocationCallbacks( allocationCallbacks )
5527	, m_dispatch( &dispatch )
5528	{}
5529
5530	Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT { return m_allocationCallbacks; }
5531
5532	protected:
5533	template <typename T>
5534	void destroy(T t) VULKAN_HPP_NOEXCEPT
5535	{
5536	VULKAN_HPP_ASSERT( m_dispatch );
5537	t.destroy( m_allocationCallbacks, *m_dispatch );
5538	}
5539
5540	private:
5541	Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
5542	Dispatch const * m_dispatch = nullptr;
5543	};
5544
5545	template <typename OwnerType, typename Dispatch>
5546	class ObjectFree
5547	{
5548	public:
5549	ObjectFree() = default;
5550
5551	ObjectFree( OwnerType owner,
5552	Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5553	Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
5554	: m_owner( owner )
5555	, m_allocationCallbacks( allocationCallbacks )
5556	, m_dispatch( &dispatch )
5557	{}
5558
5559	OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
5560	{
5561	return m_owner;
5562	}
5563
5564	Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
5565	{
5566	return m_allocationCallbacks;
5567	}
5568
5569	protected:
5570	template <typename T>
5571	void destroy( T t ) VULKAN_HPP_NOEXCEPT
5572	{
5573	VULKAN_HPP_ASSERT( m_owner && m_dispatch );
5574	( m_owner.free )( t, m_allocationCallbacks, *m_dispatch );
5575	}
5576
5577	private:
5578	OwnerType m_owner = {};
5579	Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
5580	Dispatch const * m_dispatch = nullptr;
5581	};
5582
5583	template <typename OwnerType, typename Dispatch>
5584	class ObjectRelease
5585	{
5586	public:
5587	ObjectRelease() = default;
5588
5589	ObjectRelease( OwnerType owner,
5590	Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
5591	: m_owner( owner )
5592	, m_dispatch( &dispatch )
5593	{}
5594
5595	OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
5596	{
5597	return m_owner;
5598	}
5599
5600	protected:
5601	template <typename T>
5602	void destroy( T t ) VULKAN_HPP_NOEXCEPT
5603	{
5604	VULKAN_HPP_ASSERT( m_owner && m_dispatch );
5605	m_owner.release( t, *m_dispatch );
5606	}
5607
5608	private:
5609	OwnerType m_owner = {};
5610	Dispatch const * m_dispatch = nullptr;
5611	};
5612
5613	template <typename OwnerType, typename PoolType, typename Dispatch>
5614	class PoolFree
5615	{
5616	public:
5617	PoolFree() = default;
5618
5619	PoolFree( OwnerType owner,
5620	PoolType pool,
5621	Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
5622	: m_owner( owner )
5623	, m_pool( pool )
5624	, m_dispatch( &dispatch )
5625	{}
5626
5627	OwnerType getOwner() const VULKAN_HPP_NOEXCEPT { return m_owner; }
5628	PoolType getPool() const VULKAN_HPP_NOEXCEPT { return m_pool; }
5629
5630	protected:
5631	template <typename T>
5632	void destroy(T t) VULKAN_HPP_NOEXCEPT
5633	{
5634	( m_owner.free )( m_pool, t, *m_dispatch );
5635	}
5636
5637	private:
5638	OwnerType m_owner = OwnerType();
5639	PoolType m_pool = PoolType();
5640	Dispatch const * m_dispatch = nullptr;
5641	};
5642
5643	#endif // !VULKAN_HPP_NO_SMART_HANDLE
5644
5645	//==================
5646	//=== BASE TYPEs ===
5647	//==================
5648
5649	using Bool32 = uint32_t;
5650	using DeviceAddress = uint64_t;
5651	using DeviceSize = uint64_t;
5652	using RemoteAddressNV = void *;
5653	using SampleMask = uint32_t;
5654
5655
5656	} // namespace VULKAN_HPP_NAMESPACE
5657
5658	#include <vulkan/vulkan_enums.hpp>
5659	#if !defined( VULKAN_HPP_NO_TO_STRING )
5660	#include <vulkan/vulkan_to_string.hpp>
5661	#endif
5662
5663	#ifndef VULKAN_HPP_NO_EXCEPTIONS
5664	namespace std
5665	{
5666	template <>
5667	struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type
5668	{};
5669	} // namespace std
5670	#endif
5671
5672	namespace VULKAN_HPP_NAMESPACE
5673	{
5674	#ifndef VULKAN_HPP_NO_EXCEPTIONS
5675	class ErrorCategoryImpl : public std::error_category
5676	{
5677	public:
5678	virtual const char* name() const VULKAN_HPP_NOEXCEPT override { return VULKAN_HPP_NAMESPACE_STRING"::Result"; }
5679	virtual std::string message(int ev) const override
5680	{
5681	#if defined( VULKAN_HPP_NO_TO_STRING )
5682	return std::to_string( ev );
5683	#else
5684	return VULKAN_HPP_NAMESPACE::to_string(static_cast<VULKAN_HPP_NAMESPACE::Result>(ev));
5685	#endif
5686	}
5687	};
5688
5689	class Error
5690	{
5691	public:
5692	Error() VULKAN_HPP_NOEXCEPT = default;
5693	Error(const Error&) VULKAN_HPP_NOEXCEPT = default;
5694	virtual ~Error() VULKAN_HPP_NOEXCEPT = default;
5695
5696	virtual const char* what() const VULKAN_HPP_NOEXCEPT = 0;
5697	};
5698
5699	class LogicError : public Error, public std::logic_error
5700	{
5701	public:
5702	explicit LogicError( const std::string& what )
5703	: Error(), std::logic_error(what) {}
5704	explicit LogicError( char const * what )
5705	: Error(), std::logic_error(what) {}
5706
5707	virtual const char* what() const VULKAN_HPP_NOEXCEPT { return std::logic_error::what(); }
5708	};
5709
5710	class SystemError : public Error, public std::system_error
5711	{
5712	public:
5713	SystemError( std::error_code ec )
5714	: Error(), std::system_error(ec) {}
5715	SystemError( std::error_code ec, std::string const & what )
5716	: Error(), std::system_error(ec, what) {}
5717	SystemError( std::error_code ec, char const * what )
5718	: Error(), std::system_error(ec, what) {}
5719	SystemError( int ev, std::error_category const & ecat )
5720	: Error(), std::system_error(ev, ecat) {}
5721	SystemError( int ev, std::error_category const & ecat, std::string const & what)
5722	: Error(), std::system_error(ev, ecat, what) {}
5723	SystemError( int ev, std::error_category const & ecat, char const * what)
5724	: Error(), std::system_error(ev, ecat, what) {}
5725
5726	virtual const char* what() const VULKAN_HPP_NOEXCEPT { return std::system_error::what(); }
5727	};
5728
5729	VULKAN_HPP_INLINE const std::error_category& errorCategory() VULKAN_HPP_NOEXCEPT
5730	{
5731	static ErrorCategoryImpl instance;
5732	return instance;
5733	}
5734
5735	VULKAN_HPP_INLINE std::error_code make_error_code(Result e) VULKAN_HPP_NOEXCEPT
5736	{
5737	return std::error_code(static_cast<int>(e), errorCategory());
5738	}
5739
5740	VULKAN_HPP_INLINE std::error_condition make_error_condition(Result e) VULKAN_HPP_NOEXCEPT
5741	{
5742	return std::error_condition(static_cast<int>(e), errorCategory());
5743	}
5744
5745
5746	class OutOfHostMemoryError : public SystemError
5747	{
5748	public:
5749	OutOfHostMemoryError( std::string const & message )
5750	: SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {}
5751	OutOfHostMemoryError( char const * message )
5752	: SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {}
5753	};
5754
5755	class OutOfDeviceMemoryError : public SystemError
5756	{
5757	public:
5758	OutOfDeviceMemoryError( std::string const & message )
5759	: SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {}
5760	OutOfDeviceMemoryError( char const * message )
5761	: SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {}
5762	};
5763
5764	class InitializationFailedError : public SystemError
5765	{
5766	public:
5767	InitializationFailedError( std::string const & message )
5768	: SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {}
5769	InitializationFailedError( char const * message )
5770	: SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {}
5771	};
5772
5773	class DeviceLostError : public SystemError
5774	{
5775	public:
5776	DeviceLostError( std::string const & message )
5777	: SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {}
5778	DeviceLostError( char const * message )
5779	: SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {}
5780	};
5781
5782	class MemoryMapFailedError : public SystemError
5783	{
5784	public:
5785	MemoryMapFailedError( std::string const & message )
5786	: SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {}
5787	MemoryMapFailedError( char const * message )
5788	: SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {}
5789	};
5790
5791	class LayerNotPresentError : public SystemError
5792	{
5793	public:
5794	LayerNotPresentError( std::string const & message )
5795	: SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {}
5796	LayerNotPresentError( char const * message )
5797	: SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {}
5798	};
5799
5800	class ExtensionNotPresentError : public SystemError
5801	{
5802	public:
5803	ExtensionNotPresentError( std::string const & message )
5804	: SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {}
5805	ExtensionNotPresentError( char const * message )
5806	: SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {}
5807	};
5808
5809	class FeatureNotPresentError : public SystemError
5810	{
5811	public:
5812	FeatureNotPresentError( std::string const & message )
5813	: SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {}
5814	FeatureNotPresentError( char const * message )
5815	: SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {}
5816	};
5817
5818	class IncompatibleDriverError : public SystemError
5819	{
5820	public:
5821	IncompatibleDriverError( std::string const & message )
5822	: SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {}
5823	IncompatibleDriverError( char const * message )
5824	: SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {}
5825	};
5826
5827	class TooManyObjectsError : public SystemError
5828	{
5829	public:
5830	TooManyObjectsError( std::string const & message )
5831	: SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {}
5832	TooManyObjectsError( char const * message )
5833	: SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {}
5834	};
5835
5836	class FormatNotSupportedError : public SystemError
5837	{
5838	public:
5839	FormatNotSupportedError( std::string const & message )
5840	: SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {}
5841	FormatNotSupportedError( char const * message )
5842	: SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {}
5843	};
5844
5845	class FragmentedPoolError : public SystemError
5846	{
5847	public:
5848	FragmentedPoolError( std::string const & message )
5849	: SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {}
5850	FragmentedPoolError( char const * message )
5851	: SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {}
5852	};
5853
5854	class UnknownError : public SystemError
5855	{
5856	public:
5857	UnknownError( std::string const & message )
5858	: SystemError( make_error_code( Result::eErrorUnknown ), message ) {}
5859	UnknownError( char const * message )
5860	: SystemError( make_error_code( Result::eErrorUnknown ), message ) {}
5861	};
5862
5863	class OutOfPoolMemoryError : public SystemError
5864	{
5865	public:
5866	OutOfPoolMemoryError( std::string const & message )
5867	: SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {}
5868	OutOfPoolMemoryError( char const * message )
5869	: SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {}
5870	};
5871
5872	class InvalidExternalHandleError : public SystemError
5873	{
5874	public:
5875	InvalidExternalHandleError( std::string const & message )
5876	: SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {}
5877	InvalidExternalHandleError( char const * message )
5878	: SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {}
5879	};
5880
5881	class FragmentationError : public SystemError
5882	{
5883	public:
5884	FragmentationError( std::string const & message )
5885	: SystemError( make_error_code( Result::eErrorFragmentation ), message ) {}
5886	FragmentationError( char const * message )
5887	: SystemError( make_error_code( Result::eErrorFragmentation ), message ) {}
5888	};
5889
5890	class InvalidOpaqueCaptureAddressError : public SystemError
5891	{
5892	public:
5893	InvalidOpaqueCaptureAddressError( std::string const & message )
5894	: SystemError( make_error_code( Result::eErrorInvalidOpaqueCaptureAddress ), message ) {}
5895	InvalidOpaqueCaptureAddressError( char const * message )
5896	: SystemError( make_error_code( Result::eErrorInvalidOpaqueCaptureAddress ), message ) {}
5897	};
5898
5899	class SurfaceLostKHRError : public SystemError
5900	{
5901	public:
5902	SurfaceLostKHRError( std::string const & message )
5903	: SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {}
5904	SurfaceLostKHRError( char const * message )
5905	: SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {}
5906	};
5907
5908	class NativeWindowInUseKHRError : public SystemError
5909	{
5910	public:
5911	NativeWindowInUseKHRError( std::string const & message )
5912	: SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {}
5913	NativeWindowInUseKHRError( char const * message )
5914	: SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {}
5915	};
5916
5917	class OutOfDateKHRError : public SystemError
5918	{
5919	public:
5920	OutOfDateKHRError( std::string const & message )
5921	: SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {}
5922	OutOfDateKHRError( char const * message )
5923	: SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {}
5924	};
5925
5926	class IncompatibleDisplayKHRError : public SystemError
5927	{
5928	public:
5929	IncompatibleDisplayKHRError( std::string const & message )
5930	: SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
5931	IncompatibleDisplayKHRError( char const * message )
5932	: SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
5933	};
5934
5935	class ValidationFailedEXTError : public SystemError
5936	{
5937	public:
5938	ValidationFailedEXTError( std::string const & message )
5939	: SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {}
5940	ValidationFailedEXTError( char const * message )
5941	: SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {}
5942	};
5943
5944	class InvalidShaderNVError : public SystemError
5945	{
5946	public:
5947	InvalidShaderNVError( std::string const & message )
5948	: SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {}
5949	InvalidShaderNVError( char const * message )
5950	: SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {}
5951	};
5952
5953	class ImageUsageNotSupportedKHRError : public SystemError
5954	{
5955	public:
5956	ImageUsageNotSupportedKHRError( std::string const & message )
5957	: SystemError( make_error_code( Result::eErrorImageUsageNotSupportedKHR ), message ) {}
5958	ImageUsageNotSupportedKHRError( char const * message )
5959	: SystemError( make_error_code( Result::eErrorImageUsageNotSupportedKHR ), message ) {}
5960	};
5961
5962	class VideoPictureLayoutNotSupportedKHRError : public SystemError
5963	{
5964	public:
5965	VideoPictureLayoutNotSupportedKHRError( std::string const & message )
5966	: SystemError( make_error_code( Result::eErrorVideoPictureLayoutNotSupportedKHR ), message ) {}
5967	VideoPictureLayoutNotSupportedKHRError( char const * message )
5968	: SystemError( make_error_code( Result::eErrorVideoPictureLayoutNotSupportedKHR ), message ) {}
5969	};
5970
5971	class VideoProfileOperationNotSupportedKHRError : public SystemError
5972	{
5973	public:
5974	VideoProfileOperationNotSupportedKHRError( std::string const & message )
5975	: SystemError( make_error_code( Result::eErrorVideoProfileOperationNotSupportedKHR ), message ) {}
5976	VideoProfileOperationNotSupportedKHRError( char const * message )
5977	: SystemError( make_error_code( Result::eErrorVideoProfileOperationNotSupportedKHR ), message ) {}
5978	};
5979
5980	class VideoProfileFormatNotSupportedKHRError : public SystemError
5981	{
5982	public:
5983	VideoProfileFormatNotSupportedKHRError( std::string const & message )
5984	: SystemError( make_error_code( Result::eErrorVideoProfileFormatNotSupportedKHR ), message ) {}
5985	VideoProfileFormatNotSupportedKHRError( char const * message )
5986	: SystemError( make_error_code( Result::eErrorVideoProfileFormatNotSupportedKHR ), message ) {}
5987	};
5988
5989	class VideoProfileCodecNotSupportedKHRError : public SystemError
5990	{
5991	public:
5992	VideoProfileCodecNotSupportedKHRError( std::string const & message )
5993	: SystemError( make_error_code( Result::eErrorVideoProfileCodecNotSupportedKHR ), message ) {}
5994	VideoProfileCodecNotSupportedKHRError( char const * message )
5995	: SystemError( make_error_code( Result::eErrorVideoProfileCodecNotSupportedKHR ), message ) {}
5996	};
5997
5998	class VideoStdVersionNotSupportedKHRError : public SystemError
5999	{
6000	public:
6001	VideoStdVersionNotSupportedKHRError( std::string const & message )
6002	: SystemError( make_error_code( Result::eErrorVideoStdVersionNotSupportedKHR ), message ) {}
6003	VideoStdVersionNotSupportedKHRError( char const * message )
6004	: SystemError( make_error_code( Result::eErrorVideoStdVersionNotSupportedKHR ), message ) {}
6005	};
6006
6007	class InvalidDrmFormatModifierPlaneLayoutEXTError : public SystemError
6008	{
6009	public:
6010	InvalidDrmFormatModifierPlaneLayoutEXTError( std::string const & message )
6011	: SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) {}
6012	InvalidDrmFormatModifierPlaneLayoutEXTError( char const * message )
6013	: SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) {}
6014	};
6015
6016	class NotPermittedKHRError : public SystemError
6017	{
6018	public:
6019	NotPermittedKHRError( std::string const & message )
6020	: SystemError( make_error_code( Result::eErrorNotPermittedKHR ), message ) {}
6021	NotPermittedKHRError( char const * message )
6022	: SystemError( make_error_code( Result::eErrorNotPermittedKHR ), message ) {}
6023	};
6024
6025	#if defined( VK_USE_PLATFORM_WIN32_KHR )
6026	class FullScreenExclusiveModeLostEXTError : public SystemError
6027	{
6028	public:
6029	FullScreenExclusiveModeLostEXTError( std::string const & message )
6030	: SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {}
6031	FullScreenExclusiveModeLostEXTError( char const * message )
6032	: SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {}
6033	};
6034	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
6035
6036	class CompressionExhaustedEXTError : public SystemError
6037	{
6038	public:
6039	CompressionExhaustedEXTError( std::string const & message )
6040	: SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {}
6041	CompressionExhaustedEXTError( char const * message )
6042	: SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {}
6043	};
6044
6045
6046	namespace
6047	{
6048	[[noreturn]] void throwResultException( Result result, char const * message )
6049	{
6050	switch ( result )
6051	{
6052	case Result::eErrorOutOfHostMemory: throw OutOfHostMemoryError( message );
6053	case Result::eErrorOutOfDeviceMemory: throw OutOfDeviceMemoryError( message );
6054	case Result::eErrorInitializationFailed: throw InitializationFailedError( message );
6055	case Result::eErrorDeviceLost: throw DeviceLostError( message );
6056	case Result::eErrorMemoryMapFailed: throw MemoryMapFailedError( message );
6057	case Result::eErrorLayerNotPresent: throw LayerNotPresentError( message );
6058	case Result::eErrorExtensionNotPresent: throw ExtensionNotPresentError( message );
6059	case Result::eErrorFeatureNotPresent: throw FeatureNotPresentError( message );
6060	case Result::eErrorIncompatibleDriver: throw IncompatibleDriverError( message );
6061	case Result::eErrorTooManyObjects: throw TooManyObjectsError( message );
6062	case Result::eErrorFormatNotSupported: throw FormatNotSupportedError( message );
6063	case Result::eErrorFragmentedPool: throw FragmentedPoolError( message );
6064	case Result::eErrorUnknown: throw UnknownError( message );
6065	case Result::eErrorOutOfPoolMemory: throw OutOfPoolMemoryError( message );
6066	case Result::eErrorInvalidExternalHandle: throw InvalidExternalHandleError( message );
6067	case Result::eErrorFragmentation: throw FragmentationError( message );
6068	case Result::eErrorInvalidOpaqueCaptureAddress: throw InvalidOpaqueCaptureAddressError( message );
6069	case Result::eErrorSurfaceLostKHR: throw SurfaceLostKHRError( message );
6070	case Result::eErrorNativeWindowInUseKHR: throw NativeWindowInUseKHRError( message );
6071	case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError( message );
6072	case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError( message );
6073	case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError( message );
6074	case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError( message );
6075	case Result::eErrorImageUsageNotSupportedKHR: throw ImageUsageNotSupportedKHRError( message );
6076	case Result::eErrorVideoPictureLayoutNotSupportedKHR: throw VideoPictureLayoutNotSupportedKHRError( message );
6077	case Result::eErrorVideoProfileOperationNotSupportedKHR: throw VideoProfileOperationNotSupportedKHRError( message );
6078	case Result::eErrorVideoProfileFormatNotSupportedKHR: throw VideoProfileFormatNotSupportedKHRError( message );
6079	case Result::eErrorVideoProfileCodecNotSupportedKHR: throw VideoProfileCodecNotSupportedKHRError( message );
6080	case Result::eErrorVideoStdVersionNotSupportedKHR: throw VideoStdVersionNotSupportedKHRError( message );
6081	case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError( message );
6082	case Result::eErrorNotPermittedKHR: throw NotPermittedKHRError( message );
6083	#if defined( VK_USE_PLATFORM_WIN32_KHR )
6084	case Result::eErrorFullScreenExclusiveModeLostEXT: throw FullScreenExclusiveModeLostEXTError( message );
6085	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
6086	case Result::eErrorCompressionExhaustedEXT: throw CompressionExhaustedEXTError( message );
6087	default: throw SystemError( make_error_code( result ) );
6088	}
6089	}
6090	}
6091	#endif
6092
6093	template <typename T> void ignore(T const &) VULKAN_HPP_NOEXCEPT {}
6094
6095	template <typename T>
6096	struct ResultValue
6097	{
6098	#ifdef VULKAN_HPP_HAS_NOEXCEPT
6099	ResultValue( Result r, T & v ) VULKAN_HPP_NOEXCEPT(VULKAN_HPP_NOEXCEPT(T(v)))
6100	#else
6101	ResultValue( Result r, T & v )
6102	#endif
6103	: result( r )
6104	, value( v )
6105	{}
6106
6107	#ifdef VULKAN_HPP_HAS_NOEXCEPT
6108	ResultValue( Result r, T && v ) VULKAN_HPP_NOEXCEPT(VULKAN_HPP_NOEXCEPT(T(std::move(v))))
6109	#else
6110	ResultValue( Result r, T && v )
6111	#endif
6112	: result( r )
6113	, value( std::move( v ) )
6114	{}
6115
6116	Result result;
6117	T value;
6118
6119	operator std::tuple<Result&, T&>() VULKAN_HPP_NOEXCEPT { return std::tuple<Result&, T&>(result, value); }
6120	};
6121
6122	#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
6123	template <typename Type, typename Dispatch>
6124	struct ResultValue<UniqueHandle<Type, Dispatch>>
6125	{
6126	#ifdef VULKAN_HPP_HAS_NOEXCEPT
6127	ResultValue(Result r, UniqueHandle<Type, Dispatch> && v) VULKAN_HPP_NOEXCEPT
6128	#else
6129	ResultValue(Result r, UniqueHandle<Type, Dispatch> && v)
6130	#endif
6131	: result(r)
6132	, value(std::move(v))
6133	{}
6134
6135	std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple()
6136	{
6137	return std::make_tuple( result, std::move( value ) );
6138	}
6139
6140	Result result;
6141	UniqueHandle<Type, Dispatch> value;
6142	};
6143
6144	template <typename Type, typename Dispatch>
6145	struct ResultValue<std::vector<UniqueHandle<Type, Dispatch>>>
6146	{
6147	# ifdef VULKAN_HPP_HAS_NOEXCEPT
6148	ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v ) VULKAN_HPP_NOEXCEPT
6149	# else
6150	ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v )
6151	# endif
6152	: result( r )
6153	, value( std::move( v ) )
6154	{}
6155
6156	std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple()
6157	{
6158	return std::make_tuple( result, std::move( value ) );
6159	}
6160
6161	Result result;
6162	std::vector<UniqueHandle<Type, Dispatch>> value;
6163	};
6164	#endif
6165
6166	template <typename T>
6167	struct ResultValueType
6168	{
6169	#ifdef VULKAN_HPP_NO_EXCEPTIONS
6170	typedef ResultValue<T> type;
6171	#else
6172	typedef T type;
6173	#endif
6174	};
6175
6176	template <>
6177	struct ResultValueType<void>
6178	{
6179	#ifdef VULKAN_HPP_NO_EXCEPTIONS
6180	typedef Result type;
6181	#else
6182	typedef void type;
6183	#endif
6184	};
6185
6186	VULKAN_HPP_INLINE typename ResultValueType<void>::type createResultValueType( Result result )
6187	{
6188	#ifdef VULKAN_HPP_NO_EXCEPTIONS
6189	return result;
6190	#else
6191	ignore( result );
6192	#endif
6193	}
6194
6195	template <typename T>
6196	VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValueType( Result result, T & data )
6197	{
6198	#ifdef VULKAN_HPP_NO_EXCEPTIONS
6199	return ResultValue<T>( result, data );
6200	#else
6201	ignore( result );
6202	return data;
6203	#endif
6204	}
6205
6206	template <typename T>
6207	VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValueType( Result result, T && data )
6208	{
6209	#ifdef VULKAN_HPP_NO_EXCEPTIONS
6210	return ResultValue<T>( result, std::move( data ) );
6211	#else
6212	ignore( result );
6213	return std::move( data );
6214	#endif
6215	}
6216
6217	VULKAN_HPP_INLINE void resultCheck( Result result, char const * message )
6218	{
6219	#ifdef VULKAN_HPP_NO_EXCEPTIONS
6220	ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
6221	ignore( message );
6222	VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess );
6223	#else
6224	if ( result != Result::eSuccess )
6225	{
6226	throwResultException( result, message );
6227	}
6228	#endif
6229	}
6230
6231	VULKAN_HPP_INLINE void resultCheck( Result result, char const * message, std::initializer_list<Result> successCodes )
6232	{
6233	#ifdef VULKAN_HPP_NO_EXCEPTIONS
6234	ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
6235	ignore( message );
6236	ignore( successCodes ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
6237	VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
6238	#else
6239	if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
6240	{
6241	throwResultException( result, message );
6242	}
6243	#endif
6244	}
6245	} // namespace VULKAN_HPP_NAMESPACE
6246
6247	// clang-format off
6248	#include <vulkan/vulkan_handles.hpp>
6249	#include <vulkan/vulkan_structs.hpp>
6250	#include <vulkan/vulkan_funcs.hpp>
6251	// clang-format on
6252
6253	namespace VULKAN_HPP_NAMESPACE
6254	{
6255	#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
6256
6257	//=======================
6258	//=== STRUCTS EXTENDS ===
6259	//=======================
6260
6261
6262	//=== VK_VERSION_1_0 ===
6263	template <> struct StructExtends<ShaderModuleCreateInfo, PipelineShaderStageCreateInfo>{ enum { value = true }; };
6264
6265	//=== VK_VERSION_1_1 ===
6266	template <> struct StructExtends<PhysicalDeviceSubgroupProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
6267	template <> struct StructExtends<PhysicalDevice16BitStorageFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6268	template <> struct StructExtends<PhysicalDevice16BitStorageFeatures, DeviceCreateInfo>{ enum { value = true }; };
6269	template <> struct StructExtends<MemoryDedicatedRequirements, MemoryRequirements2>{ enum { value = true }; };
6270	template <> struct StructExtends<MemoryDedicatedAllocateInfo, MemoryAllocateInfo>{ enum { value = true }; };
6271	template <> struct StructExtends<MemoryAllocateFlagsInfo, MemoryAllocateInfo>{ enum { value = true }; };
6272	template <> struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderPassBeginInfo>{ enum { value = true }; };
6273	template <> struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderingInfo>{ enum { value = true }; };
6274	template <> struct StructExtends<DeviceGroupCommandBufferBeginInfo, CommandBufferBeginInfo>{ enum { value = true }; };
6275	template <> struct StructExtends<DeviceGroupSubmitInfo, SubmitInfo>{ enum { value = true }; };
6276	template <> struct StructExtends<DeviceGroupBindSparseInfo, BindSparseInfo>{ enum { value = true }; };
6277	template <> struct StructExtends<BindBufferMemoryDeviceGroupInfo, BindBufferMemoryInfo>{ enum { value = true }; };
6278	template <> struct StructExtends<BindImageMemoryDeviceGroupInfo, BindImageMemoryInfo>{ enum { value = true }; };
6279	template <> struct StructExtends<DeviceGroupDeviceCreateInfo, DeviceCreateInfo>{ enum { value = true }; };
6280	template <> struct StructExtends<PhysicalDeviceFeatures2, DeviceCreateInfo>{ enum { value = true }; };
6281	template <> struct StructExtends<PhysicalDevicePointClippingProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
6282	template <> struct StructExtends<RenderPassInputAttachmentAspectCreateInfo, RenderPassCreateInfo>{ enum { value = true }; };
6283	template <> struct StructExtends<ImageViewUsageCreateInfo, ImageViewCreateInfo>{ enum { value = true }; };
6284	template <> struct StructExtends<PipelineTessellationDomainOriginStateCreateInfo, PipelineTessellationStateCreateInfo>{ enum { value = true }; };
6285	template <> struct StructExtends<RenderPassMultiviewCreateInfo, RenderPassCreateInfo>{ enum { value = true }; };
6286	template <> struct StructExtends<PhysicalDeviceMultiviewFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6287	template <> struct StructExtends<PhysicalDeviceMultiviewFeatures, DeviceCreateInfo>{ enum { value = true }; };
6288	template <> struct StructExtends<PhysicalDeviceMultiviewProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
6289	template <> struct StructExtends<PhysicalDeviceVariablePointersFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6290	template <> struct StructExtends<PhysicalDeviceVariablePointersFeatures, DeviceCreateInfo>{ enum { value = true }; };
6291	template <> struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6292	template <> struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, DeviceCreateInfo>{ enum { value = true }; };
6293	template <> struct StructExtends<PhysicalDeviceProtectedMemoryProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
6294	template <> struct StructExtends<ProtectedSubmitInfo, SubmitInfo>{ enum { value = true }; };
6295	template <> struct StructExtends<SamplerYcbcrConversionInfo, SamplerCreateInfo>{ enum { value = true }; };
6296	template <> struct StructExtends<SamplerYcbcrConversionInfo, ImageViewCreateInfo>{ enum { value = true }; };
6297	template <> struct StructExtends<BindImagePlaneMemoryInfo, BindImageMemoryInfo>{ enum { value = true }; };
6298	template <> struct StructExtends<ImagePlaneMemoryRequirementsInfo, ImageMemoryRequirementsInfo2>{ enum { value = true }; };
6299	template <> struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6300	template <> struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, DeviceCreateInfo>{ enum { value = true }; };
6301	template <> struct StructExtends<SamplerYcbcrConversionImageFormatProperties, ImageFormatProperties2>{ enum { value = true }; };
6302	template <> struct StructExtends<PhysicalDeviceExternalImageFormatInfo, PhysicalDeviceImageFormatInfo2>{ enum { value = true }; };
6303	template <> struct StructExtends<ExternalImageFormatProperties, ImageFormatProperties2>{ enum { value = true }; };
6304	template <> struct StructExtends<PhysicalDeviceIDProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
6305	template <> struct StructExtends<ExternalMemoryImageCreateInfo, ImageCreateInfo>{ enum { value = true }; };
6306	template <> struct StructExtends<ExternalMemoryBufferCreateInfo, BufferCreateInfo>{ enum { value = true }; };
6307	template <> struct StructExtends<ExportMemoryAllocateInfo, MemoryAllocateInfo>{ enum { value = true }; };
6308	template <> struct StructExtends<ExportFenceCreateInfo, FenceCreateInfo>{ enum { value = true }; };
6309	template <> struct StructExtends<ExportSemaphoreCreateInfo, SemaphoreCreateInfo>{ enum { value = true }; };
6310	template <> struct StructExtends<PhysicalDeviceMaintenance3Properties, PhysicalDeviceProperties2>{ enum { value = true }; };
6311	template <> struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6312	template <> struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, DeviceCreateInfo>{ enum { value = true }; };
6313
6314	//=== VK_VERSION_1_2 ===
6315	template <> struct StructExtends<PhysicalDeviceVulkan11Features, PhysicalDeviceFeatures2>{ enum { value = true }; };
6316	template <> struct StructExtends<PhysicalDeviceVulkan11Features, DeviceCreateInfo>{ enum { value = true }; };
6317	template <> struct StructExtends<PhysicalDeviceVulkan11Properties, PhysicalDeviceProperties2>{ enum { value = true }; };
6318	template <> struct StructExtends<PhysicalDeviceVulkan12Features, PhysicalDeviceFeatures2>{ enum { value = true }; };
6319	template <> struct StructExtends<PhysicalDeviceVulkan12Features, DeviceCreateInfo>{ enum { value = true }; };
6320	template <> struct StructExtends<PhysicalDeviceVulkan12Properties, PhysicalDeviceProperties2>{ enum { value = true }; };
6321	template <> struct StructExtends<ImageFormatListCreateInfo, ImageCreateInfo>{ enum { value = true }; };
6322	template <> struct StructExtends<ImageFormatListCreateInfo, SwapchainCreateInfoKHR>{ enum { value = true }; };
6323	template <> struct StructExtends<ImageFormatListCreateInfo, PhysicalDeviceImageFormatInfo2>{ enum { value = true }; };
6324	template <> struct StructExtends<PhysicalDevice8BitStorageFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6325	template <> struct StructExtends<PhysicalDevice8BitStorageFeatures, DeviceCreateInfo>{ enum { value = true }; };
6326	template <> struct StructExtends<PhysicalDeviceDriverProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
6327	template <> struct StructExtends<PhysicalDeviceShaderAtomicInt64Features, PhysicalDeviceFeatures2>{ enum { value = true }; };
6328	template <> struct StructExtends<PhysicalDeviceShaderAtomicInt64Features, DeviceCreateInfo>{ enum { value = true }; };
6329	template <> struct StructExtends<PhysicalDeviceShaderFloat16Int8Features, PhysicalDeviceFeatures2>{ enum { value = true }; };
6330	template <> struct StructExtends<PhysicalDeviceShaderFloat16Int8Features, DeviceCreateInfo>{ enum { value = true }; };
6331	template <> struct StructExtends<PhysicalDeviceFloatControlsProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
6332	template <> struct StructExtends<DescriptorSetLayoutBindingFlagsCreateInfo, DescriptorSetLayoutCreateInfo>{ enum { value = true }; };
6333	template <> struct StructExtends<PhysicalDeviceDescriptorIndexingFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6334	template <> struct StructExtends<PhysicalDeviceDescriptorIndexingFeatures, DeviceCreateInfo>{ enum { value = true }; };
6335	template <> struct StructExtends<PhysicalDeviceDescriptorIndexingProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
6336	template <> struct StructExtends<DescriptorSetVariableDescriptorCountAllocateInfo, DescriptorSetAllocateInfo>{ enum { value = true }; };
6337	template <> struct StructExtends<DescriptorSetVariableDescriptorCountLayoutSupport, DescriptorSetLayoutSupport>{ enum { value = true }; };
6338	template <> struct StructExtends<SubpassDescriptionDepthStencilResolve, SubpassDescription2>{ enum { value = true }; };
6339	template <> struct StructExtends<PhysicalDeviceDepthStencilResolveProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
6340	template <> struct StructExtends<PhysicalDeviceScalarBlockLayoutFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6341	template <> struct StructExtends<PhysicalDeviceScalarBlockLayoutFeatures, DeviceCreateInfo>{ enum { value = true }; };
6342	template <> struct StructExtends<ImageStencilUsageCreateInfo, ImageCreateInfo>{ enum { value = true }; };
6343	template <> struct StructExtends<ImageStencilUsageCreateInfo, PhysicalDeviceImageFormatInfo2>{ enum { value = true }; };
6344	template <> struct StructExtends<SamplerReductionModeCreateInfo, SamplerCreateInfo>{ enum { value = true }; };
6345	template <> struct StructExtends<PhysicalDeviceSamplerFilterMinmaxProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
6346	template <> struct StructExtends<PhysicalDeviceVulkanMemoryModelFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6347	template <> struct StructExtends<PhysicalDeviceVulkanMemoryModelFeatures, DeviceCreateInfo>{ enum { value = true }; };
6348	template <> struct StructExtends<PhysicalDeviceImagelessFramebufferFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6349	template <> struct StructExtends<PhysicalDeviceImagelessFramebufferFeatures, DeviceCreateInfo>{ enum { value = true }; };
6350	template <> struct StructExtends<FramebufferAttachmentsCreateInfo, FramebufferCreateInfo>{ enum { value = true }; };
6351	template <> struct StructExtends<RenderPassAttachmentBeginInfo, RenderPassBeginInfo>{ enum { value = true }; };
6352	template <> struct StructExtends<PhysicalDeviceUniformBufferStandardLayoutFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6353	template <> struct StructExtends<PhysicalDeviceUniformBufferStandardLayoutFeatures, DeviceCreateInfo>{ enum { value = true }; };
6354	template <> struct StructExtends<PhysicalDeviceShaderSubgroupExtendedTypesFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6355	template <> struct StructExtends<PhysicalDeviceShaderSubgroupExtendedTypesFeatures, DeviceCreateInfo>{ enum { value = true }; };
6356	template <> struct StructExtends<PhysicalDeviceSeparateDepthStencilLayoutsFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6357	template <> struct StructExtends<PhysicalDeviceSeparateDepthStencilLayoutsFeatures, DeviceCreateInfo>{ enum { value = true }; };
6358	template <> struct StructExtends<AttachmentReferenceStencilLayout, AttachmentReference2>{ enum { value = true }; };
6359	template <> struct StructExtends<AttachmentDescriptionStencilLayout, AttachmentDescription2>{ enum { value = true }; };
6360	template <> struct StructExtends<PhysicalDeviceHostQueryResetFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6361	template <> struct StructExtends<PhysicalDeviceHostQueryResetFeatures, DeviceCreateInfo>{ enum { value = true }; };
6362	template <> struct StructExtends<PhysicalDeviceTimelineSemaphoreFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6363	template <> struct StructExtends<PhysicalDeviceTimelineSemaphoreFeatures, DeviceCreateInfo>{ enum { value = true }; };
6364	template <> struct StructExtends<PhysicalDeviceTimelineSemaphoreProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
6365	template <> struct StructExtends<SemaphoreTypeCreateInfo, SemaphoreCreateInfo>{ enum { value = true }; };
6366	template <> struct StructExtends<SemaphoreTypeCreateInfo, PhysicalDeviceExternalSemaphoreInfo>{ enum { value = true }; };
6367	template <> struct StructExtends<TimelineSemaphoreSubmitInfo, SubmitInfo>{ enum { value = true }; };
6368	template <> struct StructExtends<TimelineSemaphoreSubmitInfo, BindSparseInfo>{ enum { value = true }; };
6369	template <> struct StructExtends<PhysicalDeviceBufferDeviceAddressFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6370	template <> struct StructExtends<PhysicalDeviceBufferDeviceAddressFeatures, DeviceCreateInfo>{ enum { value = true }; };
6371	template <> struct StructExtends<BufferOpaqueCaptureAddressCreateInfo, BufferCreateInfo>{ enum { value = true }; };
6372	template <> struct StructExtends<MemoryOpaqueCaptureAddressAllocateInfo, MemoryAllocateInfo>{ enum { value = true }; };
6373
6374	//=== VK_VERSION_1_3 ===
6375	template <> struct StructExtends<PhysicalDeviceVulkan13Features, PhysicalDeviceFeatures2>{ enum { value = true }; };
6376	template <> struct StructExtends<PhysicalDeviceVulkan13Features, DeviceCreateInfo>{ enum { value = true }; };
6377	template <> struct StructExtends<PhysicalDeviceVulkan13Properties, PhysicalDeviceProperties2>{ enum { value = true }; };
6378	template <> struct StructExtends<PipelineCreationFeedbackCreateInfo, GraphicsPipelineCreateInfo>{ enum { value = true }; };
6379	template <> struct StructExtends<PipelineCreationFeedbackCreateInfo, ComputePipelineCreateInfo>{ enum { value = true }; };
6380	template <> struct StructExtends<PipelineCreationFeedbackCreateInfo, RayTracingPipelineCreateInfoNV>{ enum { value = true }; };
6381	template <> struct StructExtends<PipelineCreationFeedbackCreateInfo, RayTracingPipelineCreateInfoKHR>{ enum { value = true }; };
6382	template <> struct StructExtends<PhysicalDeviceShaderTerminateInvocationFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6383	template <> struct StructExtends<PhysicalDeviceShaderTerminateInvocationFeatures, DeviceCreateInfo>{ enum { value = true }; };
6384	template <> struct StructExtends<PhysicalDeviceShaderDemoteToHelperInvocationFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6385	template <> struct StructExtends<PhysicalDeviceShaderDemoteToHelperInvocationFeatures, DeviceCreateInfo>{ enum { value = true }; };
6386	template <> struct StructExtends<PhysicalDevicePrivateDataFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6387	template <> struct StructExtends<PhysicalDevicePrivateDataFeatures, DeviceCreateInfo>{ enum { value = true }; };
6388	template <> struct StructExtends<DevicePrivateDataCreateInfo, DeviceCreateInfo>{ enum { value = true }; };
6389	template <> struct StructExtends<PhysicalDevicePipelineCreationCacheControlFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6390	template <> struct StructExtends<PhysicalDevicePipelineCreationCacheControlFeatures, DeviceCreateInfo>{ enum { value = true }; };
6391	template <> struct StructExtends<MemoryBarrier2, SubpassDependency2>{ enum { value = true }; };
6392	template <> struct StructExtends<PhysicalDeviceSynchronization2Features, PhysicalDeviceFeatures2>{ enum { value = true }; };
6393	template <> struct StructExtends<PhysicalDeviceSynchronization2Features, DeviceCreateInfo>{ enum { value = true }; };
6394	template <> struct StructExtends<PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6395	template <> struct StructExtends<PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, DeviceCreateInfo>{ enum { value = true }; };
6396	template <> struct StructExtends<PhysicalDeviceImageRobustnessFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6397	template <> struct StructExtends<PhysicalDeviceImageRobustnessFeatures, DeviceCreateInfo>{ enum { value = true }; };
6398	template <> struct StructExtends<PhysicalDeviceSubgroupSizeControlFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6399	template <> struct StructExtends<PhysicalDeviceSubgroupSizeControlFeatures, DeviceCreateInfo>{ enum { value = true }; };
6400	template <> struct StructExtends<PhysicalDeviceSubgroupSizeControlProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
6401	template <> struct StructExtends<PipelineShaderStageRequiredSubgroupSizeCreateInfo, PipelineShaderStageCreateInfo>{ enum { value = true }; };
6402	template <> struct StructExtends<PhysicalDeviceInlineUniformBlockFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6403	template <> struct StructExtends<PhysicalDeviceInlineUniformBlockFeatures, DeviceCreateInfo>{ enum { value = true }; };
6404	template <> struct StructExtends<PhysicalDeviceInlineUniformBlockProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
6405	template <> struct StructExtends<WriteDescriptorSetInlineUniformBlock, WriteDescriptorSet>{ enum { value = true }; };
6406	template <> struct StructExtends<DescriptorPoolInlineUniformBlockCreateInfo, DescriptorPoolCreateInfo>{ enum { value = true }; };
6407	template <> struct StructExtends<PhysicalDeviceTextureCompressionASTCHDRFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6408	template <> struct StructExtends<PhysicalDeviceTextureCompressionASTCHDRFeatures, DeviceCreateInfo>{ enum { value = true }; };
6409	template <> struct StructExtends<PipelineRenderingCreateInfo, GraphicsPipelineCreateInfo>{ enum { value = true }; };
6410	template <> struct StructExtends<PhysicalDeviceDynamicRenderingFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6411	template <> struct StructExtends<PhysicalDeviceDynamicRenderingFeatures, DeviceCreateInfo>{ enum { value = true }; };
6412	template <> struct StructExtends<CommandBufferInheritanceRenderingInfo, CommandBufferInheritanceInfo>{ enum { value = true }; };
6413	template <> struct StructExtends<PhysicalDeviceShaderIntegerDotProductFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
6414	template <> struct StructExtends<PhysicalDeviceShaderIntegerDotProductFeatures, DeviceCreateInfo>{ enum { value = true }; };
6415	template <> struct StructExtends<PhysicalDeviceShaderIntegerDotProductProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
6416	template <> struct StructExtends<PhysicalDeviceTexelBufferAlignmentProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
6417	template <> struct StructExtends<FormatProperties3, FormatProperties2>{ enum { value = true }; };
6418	template <> struct StructExtends<PhysicalDeviceMaintenance4Features, PhysicalDeviceFeatures2>{ enum { value = true }; };
6419	template <> struct StructExtends<PhysicalDeviceMaintenance4Features, DeviceCreateInfo>{ enum { value = true }; };
6420	template <> struct StructExtends<PhysicalDeviceMaintenance4Properties, PhysicalDeviceProperties2>{ enum { value = true }; };
6421
6422	//=== VK_KHR_swapchain ===
6423	template <> struct StructExtends<ImageSwapchainCreateInfoKHR, ImageCreateInfo>{ enum { value = true }; };
6424	template <> struct StructExtends<BindImageMemorySwapchainInfoKHR, BindImageMemoryInfo>{ enum { value = true }; };
6425	template <> struct StructExtends<DeviceGroupPresentInfoKHR, PresentInfoKHR>{ enum { value = true }; };
6426	template <> struct StructExtends<DeviceGroupSwapchainCreateInfoKHR, SwapchainCreateInfoKHR>{ enum { value = true }; };
6427
6428	//=== VK_KHR_display_swapchain ===
6429	template <> struct StructExtends<DisplayPresentInfoKHR, PresentInfoKHR>{ enum { value = true }; };
6430
6431	//=== VK_EXT_debug_report ===
6432	template <> struct StructExtends<DebugReportCallbackCreateInfoEXT, InstanceCreateInfo>{ enum { value = true }; };
6433
6434	//=== VK_AMD_rasterization_order ===
6435	template <> struct StructExtends<PipelineRasterizationStateRasterizationOrderAMD, PipelineRasterizationStateCreateInfo>{ enum { value = true }; };
6436
6437	//=== VK_KHR_video_queue ===
6438	template <> struct StructExtends<QueueFamilyQueryResultStatusPropertiesKHR, QueueFamilyProperties2>{ enum { value = true }; };
6439	template <> struct StructExtends<QueueFamilyVideoPropertiesKHR, QueueFamilyProperties2>{ enum { value = true }; };
6440	template <> struct StructExtends<VideoProfileInfoKHR, QueryPoolCreateInfo>{ enum { value = true }; };
6441	template <> struct StructExtends<VideoProfileListInfoKHR, PhysicalDeviceImageFormatInfo2>{ enum { value = true }; };
6442	template <> struct StructExtends<VideoProfileListInfoKHR, PhysicalDeviceVideoFormatInfoKHR>{ enum { value = true }; };
6443	template <> struct StructExtends<VideoProfileListInfoKHR, ImageCreateInfo>{ enum { value = true }; };
6444	template <> struct StructExtends<VideoProfileListInfoKHR, BufferCreateInfo>{ enum { value = true }; };
6445
6446	//=== VK_KHR_video_decode_queue ===
6447	template <> struct StructExtends<VideoDecodeCapabilitiesKHR, VideoCapabilitiesKHR>{ enum { value = true }; };
6448	template <> struct StructExtends<VideoDecodeUsageInfoKHR, VideoProfileInfoKHR>{ enum { value = true }; };
6449	template <> struct StructExtends<VideoDecodeUsageInfoKHR, QueryPoolCreateInfo>{ enum { value = true }; };
6450
6451	//=== VK_NV_dedicated_allocation ===
6452	template <> struct StructExtends<DedicatedAllocationImageCreateInfoNV, ImageCreateInfo>{ enum { value = true }; };
6453	template <> struct StructExtends<DedicatedAllocationBufferCreateInfoNV, BufferCreateInfo>{ enum { value = true }; };
6454	template <> struct StructExtends<DedicatedAllocationMemoryAllocateInfoNV, MemoryAllocateInfo>{ enum { value = true }; };
6455
6456	//=== VK_EXT_transform_feedback ===
6457	template <> struct StructExtends<PhysicalDeviceTransformFeedbackFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6458	template <> struct StructExtends<PhysicalDeviceTransformFeedbackFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6459	template <> struct StructExtends<PhysicalDeviceTransformFeedbackPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
6460	template <> struct StructExtends<PipelineRasterizationStateStreamCreateInfoEXT, PipelineRasterizationStateCreateInfo>{ enum { value = true }; };
6461
6462	#if defined( VK_ENABLE_BETA_EXTENSIONS )
6463	//=== VK_EXT_video_encode_h264 ===
6464	template <> struct StructExtends<VideoEncodeH264CapabilitiesEXT, VideoCapabilitiesKHR>{ enum { value = true }; };
6465	template <> struct StructExtends<VideoEncodeH264SessionParametersCreateInfoEXT, VideoSessionParametersCreateInfoKHR>{ enum { value = true }; };
6466	template <> struct StructExtends<VideoEncodeH264SessionParametersAddInfoEXT, VideoSessionParametersUpdateInfoKHR>{ enum { value = true }; };
6467	template <> struct StructExtends<VideoEncodeH264VclFrameInfoEXT, VideoEncodeInfoKHR>{ enum { value = true }; };
6468	template <> struct StructExtends<VideoEncodeH264EmitPictureParametersInfoEXT, VideoEncodeInfoKHR>{ enum { value = true }; };
6469	template <> struct StructExtends<VideoEncodeH264ProfileInfoEXT, VideoProfileInfoKHR>{ enum { value = true }; };
6470	template <> struct StructExtends<VideoEncodeH264ProfileInfoEXT, QueryPoolCreateInfo>{ enum { value = true }; };
6471	template <> struct StructExtends<VideoEncodeH264RateControlInfoEXT, VideoCodingControlInfoKHR>{ enum { value = true }; };
6472	template <> struct StructExtends<VideoEncodeH264RateControlLayerInfoEXT, VideoCodingControlInfoKHR>{ enum { value = true }; };
6473	template <> struct StructExtends<VideoEncodeH264RateControlLayerInfoEXT, VideoEncodeRateControlLayerInfoKHR>{ enum { value = true }; };
6474	#endif /*VK_ENABLE_BETA_EXTENSIONS*/
6475
6476	#if defined( VK_ENABLE_BETA_EXTENSIONS )
6477	//=== VK_EXT_video_encode_h265 ===
6478	template <> struct StructExtends<VideoEncodeH265CapabilitiesEXT, VideoCapabilitiesKHR>{ enum { value = true }; };
6479	template <> struct StructExtends<VideoEncodeH265SessionParametersCreateInfoEXT, VideoSessionParametersCreateInfoKHR>{ enum { value = true }; };
6480	template <> struct StructExtends<VideoEncodeH265SessionParametersAddInfoEXT, VideoSessionParametersUpdateInfoKHR>{ enum { value = true }; };
6481	template <> struct StructExtends<VideoEncodeH265VclFrameInfoEXT, VideoEncodeInfoKHR>{ enum { value = true }; };
6482	template <> struct StructExtends<VideoEncodeH265EmitPictureParametersInfoEXT, VideoEncodeInfoKHR>{ enum { value = true }; };
6483	template <> struct StructExtends<VideoEncodeH265ProfileInfoEXT, VideoProfileInfoKHR>{ enum { value = true }; };
6484	template <> struct StructExtends<VideoEncodeH265ProfileInfoEXT, QueryPoolCreateInfo>{ enum { value = true }; };
6485	template <> struct StructExtends<VideoEncodeH265RateControlInfoEXT, VideoCodingControlInfoKHR>{ enum { value = true }; };
6486	template <> struct StructExtends<VideoEncodeH265RateControlLayerInfoEXT, VideoCodingControlInfoKHR>{ enum { value = true }; };
6487	template <> struct StructExtends<VideoEncodeH265RateControlLayerInfoEXT, VideoEncodeRateControlLayerInfoKHR>{ enum { value = true }; };
6488	#endif /*VK_ENABLE_BETA_EXTENSIONS*/
6489
6490	//=== VK_KHR_video_decode_h264 ===
6491	template <> struct StructExtends<VideoDecodeH264ProfileInfoKHR, VideoProfileInfoKHR>{ enum { value = true }; };
6492	template <> struct StructExtends<VideoDecodeH264ProfileInfoKHR, QueryPoolCreateInfo>{ enum { value = true }; };
6493	template <> struct StructExtends<VideoDecodeH264CapabilitiesKHR, VideoCapabilitiesKHR>{ enum { value = true }; };
6494	template <> struct StructExtends<VideoDecodeH264SessionParametersCreateInfoKHR, VideoSessionParametersCreateInfoKHR>{ enum { value = true }; };
6495	template <> struct StructExtends<VideoDecodeH264SessionParametersAddInfoKHR, VideoSessionParametersUpdateInfoKHR>{ enum { value = true }; };
6496	template <> struct StructExtends<VideoDecodeH264PictureInfoKHR, VideoDecodeInfoKHR>{ enum { value = true }; };
6497	template <> struct StructExtends<VideoDecodeH264DpbSlotInfoKHR, VideoReferenceSlotInfoKHR>{ enum { value = true }; };
6498
6499	//=== VK_AMD_texture_gather_bias_lod ===
6500	template <> struct StructExtends<TextureLODGatherFormatPropertiesAMD, ImageFormatProperties2>{ enum { value = true }; };
6501
6502	//=== VK_KHR_dynamic_rendering ===
6503	template <> struct StructExtends<RenderingFragmentShadingRateAttachmentInfoKHR, RenderingInfo>{ enum { value = true }; };
6504	template <> struct StructExtends<RenderingFragmentDensityMapAttachmentInfoEXT, RenderingInfo>{ enum { value = true }; };
6505	template <> struct StructExtends<AttachmentSampleCountInfoAMD, CommandBufferInheritanceInfo>{ enum { value = true }; };
6506	template <> struct StructExtends<AttachmentSampleCountInfoAMD, GraphicsPipelineCreateInfo>{ enum { value = true }; };
6507	template <> struct StructExtends<MultiviewPerViewAttributesInfoNVX, CommandBufferInheritanceInfo>{ enum { value = true }; };
6508	template <> struct StructExtends<MultiviewPerViewAttributesInfoNVX, GraphicsPipelineCreateInfo>{ enum { value = true }; };
6509	template <> struct StructExtends<MultiviewPerViewAttributesInfoNVX, RenderingInfo>{ enum { value = true }; };
6510
6511	//=== VK_NV_corner_sampled_image ===
6512	template <> struct StructExtends<PhysicalDeviceCornerSampledImageFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
6513	template <> struct StructExtends<PhysicalDeviceCornerSampledImageFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
6514
6515	//=== VK_NV_external_memory ===
6516	template <> struct StructExtends<ExternalMemoryImageCreateInfoNV, ImageCreateInfo>{ enum { value = true }; };
6517	template <> struct StructExtends<ExportMemoryAllocateInfoNV, MemoryAllocateInfo>{ enum { value = true }; };
6518
6519	#if defined( VK_USE_PLATFORM_WIN32_KHR )
6520	//=== VK_NV_external_memory_win32 ===
6521	template <> struct StructExtends<ImportMemoryWin32HandleInfoNV, MemoryAllocateInfo>{ enum { value = true }; };
6522	template <> struct StructExtends<ExportMemoryWin32HandleInfoNV, MemoryAllocateInfo>{ enum { value = true }; };
6523	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
6524
6525	#if defined( VK_USE_PLATFORM_WIN32_KHR )
6526	//=== VK_NV_win32_keyed_mutex ===
6527	template <> struct StructExtends<Win32KeyedMutexAcquireReleaseInfoNV, SubmitInfo>{ enum { value = true }; };
6528	template <> struct StructExtends<Win32KeyedMutexAcquireReleaseInfoNV, SubmitInfo2>{ enum { value = true }; };
6529	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
6530
6531	//=== VK_EXT_validation_flags ===
6532	template <> struct StructExtends<ValidationFlagsEXT, InstanceCreateInfo>{ enum { value = true }; };
6533
6534	//=== VK_EXT_astc_decode_mode ===
6535	template <> struct StructExtends<ImageViewASTCDecodeModeEXT, ImageViewCreateInfo>{ enum { value = true }; };
6536	template <> struct StructExtends<PhysicalDeviceASTCDecodeFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6537	template <> struct StructExtends<PhysicalDeviceASTCDecodeFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6538
6539	//=== VK_EXT_pipeline_robustness ===
6540	template <> struct StructExtends<PhysicalDevicePipelineRobustnessFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6541	template <> struct StructExtends<PhysicalDevicePipelineRobustnessFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6542	template <> struct StructExtends<PhysicalDevicePipelineRobustnessPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
6543	template <> struct StructExtends<PipelineRobustnessCreateInfoEXT, GraphicsPipelineCreateInfo>{ enum { value = true }; };
6544	template <> struct StructExtends<PipelineRobustnessCreateInfoEXT, ComputePipelineCreateInfo>{ enum { value = true }; };
6545	template <> struct StructExtends<PipelineRobustnessCreateInfoEXT, PipelineShaderStageCreateInfo>{ enum { value = true }; };
6546	template <> struct StructExtends<PipelineRobustnessCreateInfoEXT, RayTracingPipelineCreateInfoKHR>{ enum { value = true }; };
6547
6548	#if defined( VK_USE_PLATFORM_WIN32_KHR )
6549	//=== VK_KHR_external_memory_win32 ===
6550	template <> struct StructExtends<ImportMemoryWin32HandleInfoKHR, MemoryAllocateInfo>{ enum { value = true }; };
6551	template <> struct StructExtends<ExportMemoryWin32HandleInfoKHR, MemoryAllocateInfo>{ enum { value = true }; };
6552	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
6553
6554	//=== VK_KHR_external_memory_fd ===
6555	template <> struct StructExtends<ImportMemoryFdInfoKHR, MemoryAllocateInfo>{ enum { value = true }; };
6556
6557	#if defined( VK_USE_PLATFORM_WIN32_KHR )
6558	//=== VK_KHR_win32_keyed_mutex ===
6559	template <> struct StructExtends<Win32KeyedMutexAcquireReleaseInfoKHR, SubmitInfo>{ enum { value = true }; };
6560	template <> struct StructExtends<Win32KeyedMutexAcquireReleaseInfoKHR, SubmitInfo2>{ enum { value = true }; };
6561	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
6562
6563	#if defined( VK_USE_PLATFORM_WIN32_KHR )
6564	//=== VK_KHR_external_semaphore_win32 ===
6565	template <> struct StructExtends<ExportSemaphoreWin32HandleInfoKHR, SemaphoreCreateInfo>{ enum { value = true }; };
6566	template <> struct StructExtends<D3D12FenceSubmitInfoKHR, SubmitInfo>{ enum { value = true }; };
6567	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
6568
6569	//=== VK_KHR_push_descriptor ===
6570	template <> struct StructExtends<PhysicalDevicePushDescriptorPropertiesKHR, PhysicalDeviceProperties2>{ enum { value = true }; };
6571
6572	//=== VK_EXT_conditional_rendering ===
6573	template <> struct StructExtends<PhysicalDeviceConditionalRenderingFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6574	template <> struct StructExtends<PhysicalDeviceConditionalRenderingFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6575	template <> struct StructExtends<CommandBufferInheritanceConditionalRenderingInfoEXT, CommandBufferInheritanceInfo>{ enum { value = true }; };
6576
6577	//=== VK_KHR_incremental_present ===
6578	template <> struct StructExtends<PresentRegionsKHR, PresentInfoKHR>{ enum { value = true }; };
6579
6580	//=== VK_NV_clip_space_w_scaling ===
6581	template <> struct StructExtends<PipelineViewportWScalingStateCreateInfoNV, PipelineViewportStateCreateInfo>{ enum { value = true }; };
6582
6583	//=== VK_EXT_display_control ===
6584	template <> struct StructExtends<SwapchainCounterCreateInfoEXT, SwapchainCreateInfoKHR>{ enum { value = true }; };
6585
6586	//=== VK_GOOGLE_display_timing ===
6587	template <> struct StructExtends<PresentTimesInfoGOOGLE, PresentInfoKHR>{ enum { value = true }; };
6588
6589	//=== VK_NVX_multiview_per_view_attributes ===
6590	template <> struct StructExtends<PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, PhysicalDeviceProperties2>{ enum { value = true }; };
6591
6592	//=== VK_NV_viewport_swizzle ===
6593	template <> struct StructExtends<PipelineViewportSwizzleStateCreateInfoNV, PipelineViewportStateCreateInfo>{ enum { value = true }; };
6594
6595	//=== VK_EXT_discard_rectangles ===
6596	template <> struct StructExtends<PhysicalDeviceDiscardRectanglePropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
6597	template <> struct StructExtends<PipelineDiscardRectangleStateCreateInfoEXT, GraphicsPipelineCreateInfo>{ enum { value = true }; };
6598
6599	//=== VK_EXT_conservative_rasterization ===
6600	template <> struct StructExtends<PhysicalDeviceConservativeRasterizationPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
6601	template <> struct StructExtends<PipelineRasterizationConservativeStateCreateInfoEXT, PipelineRasterizationStateCreateInfo>{ enum { value = true }; };
6602
6603	//=== VK_EXT_depth_clip_enable ===
6604	template <> struct StructExtends<PhysicalDeviceDepthClipEnableFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6605	template <> struct StructExtends<PhysicalDeviceDepthClipEnableFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6606	template <> struct StructExtends<PipelineRasterizationDepthClipStateCreateInfoEXT, PipelineRasterizationStateCreateInfo>{ enum { value = true }; };
6607
6608	//=== VK_KHR_shared_presentable_image ===
6609	template <> struct StructExtends<SharedPresentSurfaceCapabilitiesKHR, SurfaceCapabilities2KHR>{ enum { value = true }; };
6610
6611	#if defined( VK_USE_PLATFORM_WIN32_KHR )
6612	//=== VK_KHR_external_fence_win32 ===
6613	template <> struct StructExtends<ExportFenceWin32HandleInfoKHR, FenceCreateInfo>{ enum { value = true }; };
6614	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
6615
6616	//=== VK_KHR_performance_query ===
6617	template <> struct StructExtends<PhysicalDevicePerformanceQueryFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
6618	template <> struct StructExtends<PhysicalDevicePerformanceQueryFeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
6619	template <> struct StructExtends<PhysicalDevicePerformanceQueryPropertiesKHR, PhysicalDeviceProperties2>{ enum { value = true }; };
6620	template <> struct StructExtends<QueryPoolPerformanceCreateInfoKHR, QueryPoolCreateInfo>{ enum { value = true }; };
6621	template <> struct StructExtends<PerformanceQuerySubmitInfoKHR, SubmitInfo>{ enum { value = true }; };
6622	template <> struct StructExtends<PerformanceQuerySubmitInfoKHR, SubmitInfo2>{ enum { value = true }; };
6623
6624	//=== VK_EXT_debug_utils ===
6625	template <> struct StructExtends<DebugUtilsMessengerCreateInfoEXT, InstanceCreateInfo>{ enum { value = true }; };
6626	template <> struct StructExtends<DebugUtilsObjectNameInfoEXT, PipelineShaderStageCreateInfo>{ enum { value = true }; };
6627
6628	#if defined( VK_USE_PLATFORM_ANDROID_KHR )
6629	//=== VK_ANDROID_external_memory_android_hardware_buffer ===
6630	template <> struct StructExtends<AndroidHardwareBufferUsageANDROID, ImageFormatProperties2>{ enum { value = true }; };
6631	template <> struct StructExtends<AndroidHardwareBufferFormatPropertiesANDROID, AndroidHardwareBufferPropertiesANDROID>{ enum { value = true }; };
6632	template <> struct StructExtends<ImportAndroidHardwareBufferInfoANDROID, MemoryAllocateInfo>{ enum { value = true }; };
6633	template <> struct StructExtends<ExternalFormatANDROID, ImageCreateInfo>{ enum { value = true }; };
6634	template <> struct StructExtends<ExternalFormatANDROID, SamplerYcbcrConversionCreateInfo>{ enum { value = true }; };
6635	template <> struct StructExtends<AndroidHardwareBufferFormatProperties2ANDROID, AndroidHardwareBufferPropertiesANDROID>{ enum { value = true }; };
6636	#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
6637
6638	//=== VK_EXT_sample_locations ===
6639	template <> struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier>{ enum { value = true }; };
6640	template <> struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier2>{ enum { value = true }; };
6641	template <> struct StructExtends<RenderPassSampleLocationsBeginInfoEXT, RenderPassBeginInfo>{ enum { value = true }; };
6642	template <> struct StructExtends<PipelineSampleLocationsStateCreateInfoEXT, PipelineMultisampleStateCreateInfo>{ enum { value = true }; };
6643	template <> struct StructExtends<PhysicalDeviceSampleLocationsPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
6644
6645	//=== VK_EXT_blend_operation_advanced ===
6646	template <> struct StructExtends<PhysicalDeviceBlendOperationAdvancedFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6647	template <> struct StructExtends<PhysicalDeviceBlendOperationAdvancedFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6648	template <> struct StructExtends<PhysicalDeviceBlendOperationAdvancedPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
6649	template <> struct StructExtends<PipelineColorBlendAdvancedStateCreateInfoEXT, PipelineColorBlendStateCreateInfo>{ enum { value = true }; };
6650
6651	//=== VK_NV_fragment_coverage_to_color ===
6652	template <> struct StructExtends<PipelineCoverageToColorStateCreateInfoNV, PipelineMultisampleStateCreateInfo>{ enum { value = true }; };
6653
6654	//=== VK_KHR_acceleration_structure ===
6655	template <> struct StructExtends<WriteDescriptorSetAccelerationStructureKHR, WriteDescriptorSet>{ enum { value = true }; };
6656	template <> struct StructExtends<PhysicalDeviceAccelerationStructureFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
6657	template <> struct StructExtends<PhysicalDeviceAccelerationStructureFeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
6658	template <> struct StructExtends<PhysicalDeviceAccelerationStructurePropertiesKHR, PhysicalDeviceProperties2>{ enum { value = true }; };
6659
6660	//=== VK_NV_framebuffer_mixed_samples ===
6661	template <> struct StructExtends<PipelineCoverageModulationStateCreateInfoNV, PipelineMultisampleStateCreateInfo>{ enum { value = true }; };
6662
6663	//=== VK_NV_shader_sm_builtins ===
6664	template <> struct StructExtends<PhysicalDeviceShaderSMBuiltinsPropertiesNV, PhysicalDeviceProperties2>{ enum { value = true }; };
6665	template <> struct StructExtends<PhysicalDeviceShaderSMBuiltinsFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
6666	template <> struct StructExtends<PhysicalDeviceShaderSMBuiltinsFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
6667
6668	//=== VK_EXT_image_drm_format_modifier ===
6669	template <> struct StructExtends<DrmFormatModifierPropertiesListEXT, FormatProperties2>{ enum { value = true }; };
6670	template <> struct StructExtends<PhysicalDeviceImageDrmFormatModifierInfoEXT, PhysicalDeviceImageFormatInfo2>{ enum { value = true }; };
6671	template <> struct StructExtends<ImageDrmFormatModifierListCreateInfoEXT, ImageCreateInfo>{ enum { value = true }; };
6672	template <> struct StructExtends<ImageDrmFormatModifierExplicitCreateInfoEXT, ImageCreateInfo>{ enum { value = true }; };
6673	template <> struct StructExtends<DrmFormatModifierPropertiesList2EXT, FormatProperties2>{ enum { value = true }; };
6674
6675	//=== VK_EXT_validation_cache ===
6676	template <> struct StructExtends<ShaderModuleValidationCacheCreateInfoEXT, ShaderModuleCreateInfo>{ enum { value = true }; };
6677	template <> struct StructExtends<ShaderModuleValidationCacheCreateInfoEXT, PipelineShaderStageCreateInfo>{ enum { value = true }; };
6678
6679	#if defined( VK_ENABLE_BETA_EXTENSIONS )
6680	//=== VK_KHR_portability_subset ===
6681	template <> struct StructExtends<PhysicalDevicePortabilitySubsetFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
6682	template <> struct StructExtends<PhysicalDevicePortabilitySubsetFeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
6683	template <> struct StructExtends<PhysicalDevicePortabilitySubsetPropertiesKHR, PhysicalDeviceProperties2>{ enum { value = true }; };
6684	#endif /*VK_ENABLE_BETA_EXTENSIONS*/
6685
6686	//=== VK_NV_shading_rate_image ===
6687	template <> struct StructExtends<PipelineViewportShadingRateImageStateCreateInfoNV, PipelineViewportStateCreateInfo>{ enum { value = true }; };
6688	template <> struct StructExtends<PhysicalDeviceShadingRateImageFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
6689	template <> struct StructExtends<PhysicalDeviceShadingRateImageFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
6690	template <> struct StructExtends<PhysicalDeviceShadingRateImagePropertiesNV, PhysicalDeviceProperties2>{ enum { value = true }; };
6691	template <> struct StructExtends<PipelineViewportCoarseSampleOrderStateCreateInfoNV, PipelineViewportStateCreateInfo>{ enum { value = true }; };
6692
6693	//=== VK_NV_ray_tracing ===
6694	template <> struct StructExtends<WriteDescriptorSetAccelerationStructureNV, WriteDescriptorSet>{ enum { value = true }; };
6695	template <> struct StructExtends<PhysicalDeviceRayTracingPropertiesNV, PhysicalDeviceProperties2>{ enum { value = true }; };
6696
6697	//=== VK_NV_representative_fragment_test ===
6698	template <> struct StructExtends<PhysicalDeviceRepresentativeFragmentTestFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
6699	template <> struct StructExtends<PhysicalDeviceRepresentativeFragmentTestFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
6700	template <> struct StructExtends<PipelineRepresentativeFragmentTestStateCreateInfoNV, GraphicsPipelineCreateInfo>{ enum { value = true }; };
6701
6702	//=== VK_EXT_filter_cubic ===
6703	template <> struct StructExtends<PhysicalDeviceImageViewImageFormatInfoEXT, PhysicalDeviceImageFormatInfo2>{ enum { value = true }; };
6704	template <> struct StructExtends<FilterCubicImageViewImageFormatPropertiesEXT, ImageFormatProperties2>{ enum { value = true }; };
6705
6706	//=== VK_EXT_external_memory_host ===
6707	template <> struct StructExtends<ImportMemoryHostPointerInfoEXT, MemoryAllocateInfo>{ enum { value = true }; };
6708	template <> struct StructExtends<PhysicalDeviceExternalMemoryHostPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
6709
6710	//=== VK_KHR_shader_clock ===
6711	template <> struct StructExtends<PhysicalDeviceShaderClockFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
6712	template <> struct StructExtends<PhysicalDeviceShaderClockFeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
6713
6714	//=== VK_AMD_pipeline_compiler_control ===
6715	template <> struct StructExtends<PipelineCompilerControlCreateInfoAMD, GraphicsPipelineCreateInfo>{ enum { value = true }; };
6716	template <> struct StructExtends<PipelineCompilerControlCreateInfoAMD, ComputePipelineCreateInfo>{ enum { value = true }; };
6717
6718	//=== VK_AMD_shader_core_properties ===
6719	template <> struct StructExtends<PhysicalDeviceShaderCorePropertiesAMD, PhysicalDeviceProperties2>{ enum { value = true }; };
6720
6721	//=== VK_KHR_video_decode_h265 ===
6722	template <> struct StructExtends<VideoDecodeH265ProfileInfoKHR, VideoProfileInfoKHR>{ enum { value = true }; };
6723	template <> struct StructExtends<VideoDecodeH265ProfileInfoKHR, QueryPoolCreateInfo>{ enum { value = true }; };
6724	template <> struct StructExtends<VideoDecodeH265CapabilitiesKHR, VideoCapabilitiesKHR>{ enum { value = true }; };
6725	template <> struct StructExtends<VideoDecodeH265SessionParametersCreateInfoKHR, VideoSessionParametersCreateInfoKHR>{ enum { value = true }; };
6726	template <> struct StructExtends<VideoDecodeH265SessionParametersAddInfoKHR, VideoSessionParametersUpdateInfoKHR>{ enum { value = true }; };
6727	template <> struct StructExtends<VideoDecodeH265PictureInfoKHR, VideoDecodeInfoKHR>{ enum { value = true }; };
6728	template <> struct StructExtends<VideoDecodeH265DpbSlotInfoKHR, VideoReferenceSlotInfoKHR>{ enum { value = true }; };
6729
6730	//=== VK_KHR_global_priority ===
6731	template <> struct StructExtends<DeviceQueueGlobalPriorityCreateInfoKHR, DeviceQueueCreateInfo>{ enum { value = true }; };
6732	template <> struct StructExtends<PhysicalDeviceGlobalPriorityQueryFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
6733	template <> struct StructExtends<PhysicalDeviceGlobalPriorityQueryFeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
6734	template <> struct StructExtends<QueueFamilyGlobalPriorityPropertiesKHR, QueueFamilyProperties2>{ enum { value = true }; };
6735
6736	//=== VK_AMD_memory_overallocation_behavior ===
6737	template <> struct StructExtends<DeviceMemoryOverallocationCreateInfoAMD, DeviceCreateInfo>{ enum { value = true }; };
6738
6739	//=== VK_EXT_vertex_attribute_divisor ===
6740	template <> struct StructExtends<PhysicalDeviceVertexAttributeDivisorPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
6741	template <> struct StructExtends<PipelineVertexInputDivisorStateCreateInfoEXT, PipelineVertexInputStateCreateInfo>{ enum { value = true }; };
6742	template <> struct StructExtends<PhysicalDeviceVertexAttributeDivisorFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6743	template <> struct StructExtends<PhysicalDeviceVertexAttributeDivisorFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6744
6745	#if defined( VK_USE_PLATFORM_GGP )
6746	//=== VK_GGP_frame_token ===
6747	template <> struct StructExtends<PresentFrameTokenGGP, PresentInfoKHR>{ enum { value = true }; };
6748	#endif /*VK_USE_PLATFORM_GGP*/
6749
6750	//=== VK_NV_compute_shader_derivatives ===
6751	template <> struct StructExtends<PhysicalDeviceComputeShaderDerivativesFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
6752	template <> struct StructExtends<PhysicalDeviceComputeShaderDerivativesFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
6753
6754	//=== VK_NV_mesh_shader ===
6755	template <> struct StructExtends<PhysicalDeviceMeshShaderFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
6756	template <> struct StructExtends<PhysicalDeviceMeshShaderFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
6757	template <> struct StructExtends<PhysicalDeviceMeshShaderPropertiesNV, PhysicalDeviceProperties2>{ enum { value = true }; };
6758
6759	//=== VK_NV_shader_image_footprint ===
6760	template <> struct StructExtends<PhysicalDeviceShaderImageFootprintFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
6761	template <> struct StructExtends<PhysicalDeviceShaderImageFootprintFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
6762
6763	//=== VK_NV_scissor_exclusive ===
6764	template <> struct StructExtends<PipelineViewportExclusiveScissorStateCreateInfoNV, PipelineViewportStateCreateInfo>{ enum { value = true }; };
6765	template <> struct StructExtends<PhysicalDeviceExclusiveScissorFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
6766	template <> struct StructExtends<PhysicalDeviceExclusiveScissorFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
6767
6768	//=== VK_NV_device_diagnostic_checkpoints ===
6769	template <> struct StructExtends<QueueFamilyCheckpointPropertiesNV, QueueFamilyProperties2>{ enum { value = true }; };
6770
6771	//=== VK_INTEL_shader_integer_functions2 ===
6772	template <> struct StructExtends<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, PhysicalDeviceFeatures2>{ enum { value = true }; };
6773	template <> struct StructExtends<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, DeviceCreateInfo>{ enum { value = true }; };
6774
6775	//=== VK_INTEL_performance_query ===
6776	template <> struct StructExtends<QueryPoolPerformanceQueryCreateInfoINTEL, QueryPoolCreateInfo>{ enum { value = true }; };
6777
6778	//=== VK_EXT_pci_bus_info ===
6779	template <> struct StructExtends<PhysicalDevicePCIBusInfoPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
6780
6781	//=== VK_AMD_display_native_hdr ===
6782	template <> struct StructExtends<DisplayNativeHdrSurfaceCapabilitiesAMD, SurfaceCapabilities2KHR>{ enum { value = true }; };
6783	template <> struct StructExtends<SwapchainDisplayNativeHdrCreateInfoAMD, SwapchainCreateInfoKHR>{ enum { value = true }; };
6784
6785	//=== VK_EXT_fragment_density_map ===
6786	template <> struct StructExtends<PhysicalDeviceFragmentDensityMapFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6787	template <> struct StructExtends<PhysicalDeviceFragmentDensityMapFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6788	template <> struct StructExtends<PhysicalDeviceFragmentDensityMapPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
6789	template <> struct StructExtends<RenderPassFragmentDensityMapCreateInfoEXT, RenderPassCreateInfo>{ enum { value = true }; };
6790	template <> struct StructExtends<RenderPassFragmentDensityMapCreateInfoEXT, RenderPassCreateInfo2>{ enum { value = true }; };
6791
6792	//=== VK_KHR_fragment_shading_rate ===
6793	template <> struct StructExtends<FragmentShadingRateAttachmentInfoKHR, SubpassDescription2>{ enum { value = true }; };
6794	template <> struct StructExtends<PipelineFragmentShadingRateStateCreateInfoKHR, GraphicsPipelineCreateInfo>{ enum { value = true }; };
6795	template <> struct StructExtends<PhysicalDeviceFragmentShadingRateFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
6796	template <> struct StructExtends<PhysicalDeviceFragmentShadingRateFeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
6797	template <> struct StructExtends<PhysicalDeviceFragmentShadingRatePropertiesKHR, PhysicalDeviceProperties2>{ enum { value = true }; };
6798
6799	//=== VK_AMD_shader_core_properties2 ===
6800	template <> struct StructExtends<PhysicalDeviceShaderCoreProperties2AMD, PhysicalDeviceProperties2>{ enum { value = true }; };
6801
6802	//=== VK_AMD_device_coherent_memory ===
6803	template <> struct StructExtends<PhysicalDeviceCoherentMemoryFeaturesAMD, PhysicalDeviceFeatures2>{ enum { value = true }; };
6804	template <> struct StructExtends<PhysicalDeviceCoherentMemoryFeaturesAMD, DeviceCreateInfo>{ enum { value = true }; };
6805
6806	//=== VK_EXT_shader_image_atomic_int64 ===
6807	template <> struct StructExtends<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6808	template <> struct StructExtends<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6809
6810	//=== VK_EXT_memory_budget ===
6811	template <> struct StructExtends<PhysicalDeviceMemoryBudgetPropertiesEXT, PhysicalDeviceMemoryProperties2>{ enum { value = true }; };
6812
6813	//=== VK_EXT_memory_priority ===
6814	template <> struct StructExtends<PhysicalDeviceMemoryPriorityFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6815	template <> struct StructExtends<PhysicalDeviceMemoryPriorityFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6816	template <> struct StructExtends<MemoryPriorityAllocateInfoEXT, MemoryAllocateInfo>{ enum { value = true }; };
6817
6818	//=== VK_KHR_surface_protected_capabilities ===
6819	template <> struct StructExtends<SurfaceProtectedCapabilitiesKHR, SurfaceCapabilities2KHR>{ enum { value = true }; };
6820
6821	//=== VK_NV_dedicated_allocation_image_aliasing ===
6822	template <> struct StructExtends<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
6823	template <> struct StructExtends<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
6824
6825	//=== VK_EXT_buffer_device_address ===
6826	template <> struct StructExtends<PhysicalDeviceBufferDeviceAddressFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6827	template <> struct StructExtends<PhysicalDeviceBufferDeviceAddressFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6828	template <> struct StructExtends<BufferDeviceAddressCreateInfoEXT, BufferCreateInfo>{ enum { value = true }; };
6829
6830	//=== VK_EXT_validation_features ===
6831	template <> struct StructExtends<ValidationFeaturesEXT, InstanceCreateInfo>{ enum { value = true }; };
6832
6833	//=== VK_KHR_present_wait ===
6834	template <> struct StructExtends<PhysicalDevicePresentWaitFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
6835	template <> struct StructExtends<PhysicalDevicePresentWaitFeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
6836
6837	//=== VK_NV_cooperative_matrix ===
6838	template <> struct StructExtends<PhysicalDeviceCooperativeMatrixFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
6839	template <> struct StructExtends<PhysicalDeviceCooperativeMatrixFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
6840	template <> struct StructExtends<PhysicalDeviceCooperativeMatrixPropertiesNV, PhysicalDeviceProperties2>{ enum { value = true }; };
6841
6842	//=== VK_NV_coverage_reduction_mode ===
6843	template <> struct StructExtends<PhysicalDeviceCoverageReductionModeFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
6844	template <> struct StructExtends<PhysicalDeviceCoverageReductionModeFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
6845	template <> struct StructExtends<PipelineCoverageReductionStateCreateInfoNV, PipelineMultisampleStateCreateInfo>{ enum { value = true }; };
6846
6847	//=== VK_EXT_fragment_shader_interlock ===
6848	template <> struct StructExtends<PhysicalDeviceFragmentShaderInterlockFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6849	template <> struct StructExtends<PhysicalDeviceFragmentShaderInterlockFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6850
6851	//=== VK_EXT_ycbcr_image_arrays ===
6852	template <> struct StructExtends<PhysicalDeviceYcbcrImageArraysFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6853	template <> struct StructExtends<PhysicalDeviceYcbcrImageArraysFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6854
6855	//=== VK_EXT_provoking_vertex ===
6856	template <> struct StructExtends<PhysicalDeviceProvokingVertexFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6857	template <> struct StructExtends<PhysicalDeviceProvokingVertexFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6858	template <> struct StructExtends<PhysicalDeviceProvokingVertexPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
6859	template <> struct StructExtends<PipelineRasterizationProvokingVertexStateCreateInfoEXT, PipelineRasterizationStateCreateInfo>{ enum { value = true }; };
6860
6861	#if defined( VK_USE_PLATFORM_WIN32_KHR )
6862	//=== VK_EXT_full_screen_exclusive ===
6863	template <> struct StructExtends<SurfaceFullScreenExclusiveInfoEXT, PhysicalDeviceSurfaceInfo2KHR>{ enum { value = true }; };
6864	template <> struct StructExtends<SurfaceFullScreenExclusiveInfoEXT, SwapchainCreateInfoKHR>{ enum { value = true }; };
6865	template <> struct StructExtends<SurfaceCapabilitiesFullScreenExclusiveEXT, SurfaceCapabilities2KHR>{ enum { value = true }; };
6866	template <> struct StructExtends<SurfaceFullScreenExclusiveWin32InfoEXT, PhysicalDeviceSurfaceInfo2KHR>{ enum { value = true }; };
6867	template <> struct StructExtends<SurfaceFullScreenExclusiveWin32InfoEXT, SwapchainCreateInfoKHR>{ enum { value = true }; };
6868	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
6869
6870	//=== VK_EXT_line_rasterization ===
6871	template <> struct StructExtends<PhysicalDeviceLineRasterizationFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6872	template <> struct StructExtends<PhysicalDeviceLineRasterizationFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6873	template <> struct StructExtends<PhysicalDeviceLineRasterizationPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
6874	template <> struct StructExtends<PipelineRasterizationLineStateCreateInfoEXT, PipelineRasterizationStateCreateInfo>{ enum { value = true }; };
6875
6876	//=== VK_EXT_shader_atomic_float ===
6877	template <> struct StructExtends<PhysicalDeviceShaderAtomicFloatFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6878	template <> struct StructExtends<PhysicalDeviceShaderAtomicFloatFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6879
6880	//=== VK_EXT_index_type_uint8 ===
6881	template <> struct StructExtends<PhysicalDeviceIndexTypeUint8FeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6882	template <> struct StructExtends<PhysicalDeviceIndexTypeUint8FeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6883
6884	//=== VK_EXT_extended_dynamic_state ===
6885	template <> struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6886	template <> struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6887
6888	//=== VK_KHR_pipeline_executable_properties ===
6889	template <> struct StructExtends<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
6890	template <> struct StructExtends<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
6891
6892	//=== VK_EXT_shader_atomic_float2 ===
6893	template <> struct StructExtends<PhysicalDeviceShaderAtomicFloat2FeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6894	template <> struct StructExtends<PhysicalDeviceShaderAtomicFloat2FeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6895
6896	//=== VK_EXT_surface_maintenance1 ===
6897	template <> struct StructExtends<SurfacePresentModeEXT, PhysicalDeviceSurfaceInfo2KHR>{ enum { value = true }; };
6898	template <> struct StructExtends<SurfacePresentScalingCapabilitiesEXT, SurfaceCapabilities2KHR>{ enum { value = true }; };
6899	template <> struct StructExtends<SurfacePresentModeCompatibilityEXT, SurfaceCapabilities2KHR>{ enum { value = true }; };
6900
6901	//=== VK_EXT_swapchain_maintenance1 ===
6902	template <> struct StructExtends<PhysicalDeviceSwapchainMaintenance1FeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6903	template <> struct StructExtends<PhysicalDeviceSwapchainMaintenance1FeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6904	template <> struct StructExtends<SwapchainPresentFenceInfoEXT, PresentInfoKHR>{ enum { value = true }; };
6905	template <> struct StructExtends<SwapchainPresentModesCreateInfoEXT, SwapchainCreateInfoKHR>{ enum { value = true }; };
6906	template <> struct StructExtends<SwapchainPresentModeInfoEXT, PresentInfoKHR>{ enum { value = true }; };
6907	template <> struct StructExtends<SwapchainPresentScalingCreateInfoEXT, SwapchainCreateInfoKHR>{ enum { value = true }; };
6908
6909	//=== VK_NV_device_generated_commands ===
6910	template <> struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, PhysicalDeviceProperties2>{ enum { value = true }; };
6911	template <> struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
6912	template <> struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
6913	template <> struct StructExtends<GraphicsPipelineShaderGroupsCreateInfoNV, GraphicsPipelineCreateInfo>{ enum { value = true }; };
6914
6915	//=== VK_NV_inherited_viewport_scissor ===
6916	template <> struct StructExtends<PhysicalDeviceInheritedViewportScissorFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
6917	template <> struct StructExtends<PhysicalDeviceInheritedViewportScissorFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
6918	template <> struct StructExtends<CommandBufferInheritanceViewportScissorInfoNV, CommandBufferInheritanceInfo>{ enum { value = true }; };
6919
6920	//=== VK_EXT_texel_buffer_alignment ===
6921	template <> struct StructExtends<PhysicalDeviceTexelBufferAlignmentFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6922	template <> struct StructExtends<PhysicalDeviceTexelBufferAlignmentFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6923
6924	//=== VK_QCOM_render_pass_transform ===
6925	template <> struct StructExtends<RenderPassTransformBeginInfoQCOM, RenderPassBeginInfo>{ enum { value = true }; };
6926	template <> struct StructExtends<CommandBufferInheritanceRenderPassTransformInfoQCOM, CommandBufferInheritanceInfo>{ enum { value = true }; };
6927
6928	//=== VK_EXT_device_memory_report ===
6929	template <> struct StructExtends<PhysicalDeviceDeviceMemoryReportFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6930	template <> struct StructExtends<PhysicalDeviceDeviceMemoryReportFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6931	template <> struct StructExtends<DeviceDeviceMemoryReportCreateInfoEXT, DeviceCreateInfo>{ enum { value = true }; };
6932
6933	//=== VK_EXT_robustness2 ===
6934	template <> struct StructExtends<PhysicalDeviceRobustness2FeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6935	template <> struct StructExtends<PhysicalDeviceRobustness2FeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6936	template <> struct StructExtends<PhysicalDeviceRobustness2PropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
6937
6938	//=== VK_EXT_custom_border_color ===
6939	template <> struct StructExtends<SamplerCustomBorderColorCreateInfoEXT, SamplerCreateInfo>{ enum { value = true }; };
6940	template <> struct StructExtends<PhysicalDeviceCustomBorderColorPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
6941	template <> struct StructExtends<PhysicalDeviceCustomBorderColorFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
6942	template <> struct StructExtends<PhysicalDeviceCustomBorderColorFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
6943
6944	//=== VK_KHR_pipeline_library ===
6945	template <> struct StructExtends<PipelineLibraryCreateInfoKHR, GraphicsPipelineCreateInfo>{ enum { value = true }; };
6946
6947	//=== VK_NV_present_barrier ===
6948	template <> struct StructExtends<PhysicalDevicePresentBarrierFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
6949	template <> struct StructExtends<PhysicalDevicePresentBarrierFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
6950	template <> struct StructExtends<SurfaceCapabilitiesPresentBarrierNV, SurfaceCapabilities2KHR>{ enum { value = true }; };
6951	template <> struct StructExtends<SwapchainPresentBarrierCreateInfoNV, SwapchainCreateInfoKHR>{ enum { value = true }; };
6952
6953	//=== VK_KHR_present_id ===
6954	template <> struct StructExtends<PresentIdKHR, PresentInfoKHR>{ enum { value = true }; };
6955	template <> struct StructExtends<PhysicalDevicePresentIdFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
6956	template <> struct StructExtends<PhysicalDevicePresentIdFeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
6957
6958	#if defined( VK_ENABLE_BETA_EXTENSIONS )
6959	//=== VK_KHR_video_encode_queue ===
6960	template <> struct StructExtends<VideoEncodeCapabilitiesKHR, VideoCapabilitiesKHR>{ enum { value = true }; };
6961	template <> struct StructExtends<VideoEncodeUsageInfoKHR, VideoProfileInfoKHR>{ enum { value = true }; };
6962	template <> struct StructExtends<VideoEncodeUsageInfoKHR, QueryPoolCreateInfo>{ enum { value = true }; };
6963	template <> struct StructExtends<VideoEncodeRateControlInfoKHR, VideoCodingControlInfoKHR>{ enum { value = true }; };
6964	template <> struct StructExtends<VideoEncodeRateControlLayerInfoKHR, VideoCodingControlInfoKHR>{ enum { value = true }; };
6965	#endif /*VK_ENABLE_BETA_EXTENSIONS*/
6966
6967	//=== VK_NV_device_diagnostics_config ===
6968	template <> struct StructExtends<PhysicalDeviceDiagnosticsConfigFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
6969	template <> struct StructExtends<PhysicalDeviceDiagnosticsConfigFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
6970	template <> struct StructExtends<DeviceDiagnosticsConfigCreateInfoNV, DeviceCreateInfo>{ enum { value = true }; };
6971
6972	#if defined( VK_USE_PLATFORM_METAL_EXT )
6973	//=== VK_EXT_metal_objects ===
6974	template <> struct StructExtends<ExportMetalObjectCreateInfoEXT, InstanceCreateInfo>{ enum { value = true }; };
6975	template <> struct StructExtends<ExportMetalObjectCreateInfoEXT, MemoryAllocateInfo>{ enum { value = true }; };
6976	template <> struct StructExtends<ExportMetalObjectCreateInfoEXT, ImageCreateInfo>{ enum { value = true }; };
6977	template <> struct StructExtends<ExportMetalObjectCreateInfoEXT, ImageViewCreateInfo>{ enum { value = true }; };
6978	template <> struct StructExtends<ExportMetalObjectCreateInfoEXT, BufferViewCreateInfo>{ enum { value = true }; };
6979	template <> struct StructExtends<ExportMetalObjectCreateInfoEXT, SemaphoreCreateInfo>{ enum { value = true }; };
6980	template <> struct StructExtends<ExportMetalObjectCreateInfoEXT, EventCreateInfo>{ enum { value = true }; };
6981	template <> struct StructExtends<ExportMetalDeviceInfoEXT, ExportMetalObjectsInfoEXT>{ enum { value = true }; };
6982	template <> struct StructExtends<ExportMetalCommandQueueInfoEXT, ExportMetalObjectsInfoEXT>{ enum { value = true }; };
6983	template <> struct StructExtends<ExportMetalBufferInfoEXT, ExportMetalObjectsInfoEXT>{ enum { value = true }; };
6984	template <> struct StructExtends<ImportMetalBufferInfoEXT, MemoryAllocateInfo>{ enum { value = true }; };
6985	template <> struct StructExtends<ExportMetalTextureInfoEXT, ExportMetalObjectsInfoEXT>{ enum { value = true }; };
6986	template <> struct StructExtends<ImportMetalTextureInfoEXT, ImageCreateInfo>{ enum { value = true }; };
6987	template <> struct StructExtends<ExportMetalIOSurfaceInfoEXT, ExportMetalObjectsInfoEXT>{ enum { value = true }; };
6988	template <> struct StructExtends<ImportMetalIOSurfaceInfoEXT, ImageCreateInfo>{ enum { value = true }; };
6989	template <> struct StructExtends<ExportMetalSharedEventInfoEXT, ExportMetalObjectsInfoEXT>{ enum { value = true }; };
6990	template <> struct StructExtends<ImportMetalSharedEventInfoEXT, SemaphoreCreateInfo>{ enum { value = true }; };
6991	template <> struct StructExtends<ImportMetalSharedEventInfoEXT, EventCreateInfo>{ enum { value = true }; };
6992	#endif /*VK_USE_PLATFORM_METAL_EXT*/
6993
6994	//=== VK_KHR_synchronization2 ===
6995	template <> struct StructExtends<QueueFamilyCheckpointProperties2NV, QueueFamilyProperties2>{ enum { value = true }; };
6996
6997	//=== VK_EXT_descriptor_buffer ===
6998	template <> struct StructExtends<PhysicalDeviceDescriptorBufferPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
6999	template <> struct StructExtends<PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
7000	template <> struct StructExtends<PhysicalDeviceDescriptorBufferFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7001	template <> struct StructExtends<PhysicalDeviceDescriptorBufferFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7002	template <> struct StructExtends<DescriptorBufferBindingPushDescriptorBufferHandleEXT, DescriptorBufferBindingInfoEXT>{ enum { value = true }; };
7003	template <> struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, BufferCreateInfo>{ enum { value = true }; };
7004	template <> struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, ImageCreateInfo>{ enum { value = true }; };
7005	template <> struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, ImageViewCreateInfo>{ enum { value = true }; };
7006	template <> struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, SamplerCreateInfo>{ enum { value = true }; };
7007	template <> struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, AccelerationStructureCreateInfoKHR>{ enum { value = true }; };
7008	template <> struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, AccelerationStructureCreateInfoNV>{ enum { value = true }; };
7009
7010	//=== VK_EXT_graphics_pipeline_library ===
7011	template <> struct StructExtends<PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7012	template <> struct StructExtends<PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7013	template <> struct StructExtends<PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
7014	template <> struct StructExtends<GraphicsPipelineLibraryCreateInfoEXT, GraphicsPipelineCreateInfo>{ enum { value = true }; };
7015
7016	//=== VK_AMD_shader_early_and_late_fragment_tests ===
7017	template <> struct StructExtends<PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, PhysicalDeviceFeatures2>{ enum { value = true }; };
7018	template <> struct StructExtends<PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, DeviceCreateInfo>{ enum { value = true }; };
7019
7020	//=== VK_KHR_fragment_shader_barycentric ===
7021	template <> struct StructExtends<PhysicalDeviceFragmentShaderBarycentricFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
7022	template <> struct StructExtends<PhysicalDeviceFragmentShaderBarycentricFeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
7023	template <> struct StructExtends<PhysicalDeviceFragmentShaderBarycentricPropertiesKHR, PhysicalDeviceProperties2>{ enum { value = true }; };
7024
7025	//=== VK_KHR_shader_subgroup_uniform_control_flow ===
7026	template <> struct StructExtends<PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
7027	template <> struct StructExtends<PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
7028
7029	//=== VK_NV_fragment_shading_rate_enums ===
7030	template <> struct StructExtends<PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
7031	template <> struct StructExtends<PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
7032	template <> struct StructExtends<PhysicalDeviceFragmentShadingRateEnumsPropertiesNV, PhysicalDeviceProperties2>{ enum { value = true }; };
7033	template <> struct StructExtends<PipelineFragmentShadingRateEnumStateCreateInfoNV, GraphicsPipelineCreateInfo>{ enum { value = true }; };
7034
7035	//=== VK_NV_ray_tracing_motion_blur ===
7036	template <> struct StructExtends<AccelerationStructureGeometryMotionTrianglesDataNV, AccelerationStructureGeometryTrianglesDataKHR>{ enum { value = true }; };
7037	template <> struct StructExtends<AccelerationStructureMotionInfoNV, AccelerationStructureCreateInfoKHR>{ enum { value = true }; };
7038	template <> struct StructExtends<PhysicalDeviceRayTracingMotionBlurFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
7039	template <> struct StructExtends<PhysicalDeviceRayTracingMotionBlurFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
7040
7041	//=== VK_EXT_mesh_shader ===
7042	template <> struct StructExtends<PhysicalDeviceMeshShaderFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7043	template <> struct StructExtends<PhysicalDeviceMeshShaderFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7044	template <> struct StructExtends<PhysicalDeviceMeshShaderPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
7045
7046	//=== VK_EXT_ycbcr_2plane_444_formats ===
7047	template <> struct StructExtends<PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7048	template <> struct StructExtends<PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7049
7050	//=== VK_EXT_fragment_density_map2 ===
7051	template <> struct StructExtends<PhysicalDeviceFragmentDensityMap2FeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7052	template <> struct StructExtends<PhysicalDeviceFragmentDensityMap2FeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7053	template <> struct StructExtends<PhysicalDeviceFragmentDensityMap2PropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
7054
7055	//=== VK_QCOM_rotated_copy_commands ===
7056	template <> struct StructExtends<CopyCommandTransformInfoQCOM, BufferImageCopy2>{ enum { value = true }; };
7057	template <> struct StructExtends<CopyCommandTransformInfoQCOM, ImageBlit2>{ enum { value = true }; };
7058
7059	//=== VK_KHR_workgroup_memory_explicit_layout ===
7060	template <> struct StructExtends<PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
7061	template <> struct StructExtends<PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
7062
7063	//=== VK_EXT_image_compression_control ===
7064	template <> struct StructExtends<PhysicalDeviceImageCompressionControlFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7065	template <> struct StructExtends<PhysicalDeviceImageCompressionControlFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7066	template <> struct StructExtends<ImageCompressionControlEXT, ImageCreateInfo>{ enum { value = true }; };
7067	template <> struct StructExtends<ImageCompressionControlEXT, SwapchainCreateInfoKHR>{ enum { value = true }; };
7068	template <> struct StructExtends<ImageCompressionControlEXT, PhysicalDeviceImageFormatInfo2>{ enum { value = true }; };
7069	template <> struct StructExtends<ImageCompressionPropertiesEXT, ImageFormatProperties2>{ enum { value = true }; };
7070	template <> struct StructExtends<ImageCompressionPropertiesEXT, SurfaceFormat2KHR>{ enum { value = true }; };
7071	template <> struct StructExtends<ImageCompressionPropertiesEXT, SubresourceLayout2EXT>{ enum { value = true }; };
7072
7073	//=== VK_EXT_attachment_feedback_loop_layout ===
7074	template <> struct StructExtends<PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7075	template <> struct StructExtends<PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7076
7077	//=== VK_EXT_4444_formats ===
7078	template <> struct StructExtends<PhysicalDevice4444FormatsFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7079	template <> struct StructExtends<PhysicalDevice4444FormatsFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7080
7081	//=== VK_EXT_device_fault ===
7082	template <> struct StructExtends<PhysicalDeviceFaultFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7083	template <> struct StructExtends<PhysicalDeviceFaultFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7084
7085	//=== VK_EXT_rgba10x6_formats ===
7086	template <> struct StructExtends<PhysicalDeviceRGBA10X6FormatsFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7087	template <> struct StructExtends<PhysicalDeviceRGBA10X6FormatsFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7088
7089	//=== VK_KHR_ray_tracing_pipeline ===
7090	template <> struct StructExtends<PhysicalDeviceRayTracingPipelineFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
7091	template <> struct StructExtends<PhysicalDeviceRayTracingPipelineFeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
7092	template <> struct StructExtends<PhysicalDeviceRayTracingPipelinePropertiesKHR, PhysicalDeviceProperties2>{ enum { value = true }; };
7093
7094	//=== VK_KHR_ray_query ===
7095	template <> struct StructExtends<PhysicalDeviceRayQueryFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
7096	template <> struct StructExtends<PhysicalDeviceRayQueryFeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
7097
7098	//=== VK_EXT_vertex_input_dynamic_state ===
7099	template <> struct StructExtends<PhysicalDeviceVertexInputDynamicStateFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7100	template <> struct StructExtends<PhysicalDeviceVertexInputDynamicStateFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7101
7102	//=== VK_EXT_physical_device_drm ===
7103	template <> struct StructExtends<PhysicalDeviceDrmPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
7104
7105	//=== VK_EXT_device_address_binding_report ===
7106	template <> struct StructExtends<PhysicalDeviceAddressBindingReportFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7107	template <> struct StructExtends<PhysicalDeviceAddressBindingReportFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7108	template <> struct StructExtends<DeviceAddressBindingCallbackDataEXT, DebugUtilsMessengerCallbackDataEXT>{ enum { value = true }; };
7109
7110	//=== VK_EXT_depth_clip_control ===
7111	template <> struct StructExtends<PhysicalDeviceDepthClipControlFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7112	template <> struct StructExtends<PhysicalDeviceDepthClipControlFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7113	template <> struct StructExtends<PipelineViewportDepthClipControlCreateInfoEXT, PipelineViewportStateCreateInfo>{ enum { value = true }; };
7114
7115	//=== VK_EXT_primitive_topology_list_restart ===
7116	template <> struct StructExtends<PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7117	template <> struct StructExtends<PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7118
7119	#if defined( VK_USE_PLATFORM_FUCHSIA )
7120	//=== VK_FUCHSIA_external_memory ===
7121	template <> struct StructExtends<ImportMemoryZirconHandleInfoFUCHSIA, MemoryAllocateInfo>{ enum { value = true }; };
7122	#endif /*VK_USE_PLATFORM_FUCHSIA*/
7123
7124	#if defined( VK_USE_PLATFORM_FUCHSIA )
7125	//=== VK_FUCHSIA_buffer_collection ===
7126	template <> struct StructExtends<ImportMemoryBufferCollectionFUCHSIA, MemoryAllocateInfo>{ enum { value = true }; };
7127	template <> struct StructExtends<BufferCollectionImageCreateInfoFUCHSIA, ImageCreateInfo>{ enum { value = true }; };
7128	template <> struct StructExtends<BufferCollectionBufferCreateInfoFUCHSIA, BufferCreateInfo>{ enum { value = true }; };
7129	#endif /*VK_USE_PLATFORM_FUCHSIA*/
7130
7131	//=== VK_HUAWEI_subpass_shading ===
7132	template <> struct StructExtends<SubpassShadingPipelineCreateInfoHUAWEI, ComputePipelineCreateInfo>{ enum { value = true }; };
7133	template <> struct StructExtends<PhysicalDeviceSubpassShadingFeaturesHUAWEI, PhysicalDeviceFeatures2>{ enum { value = true }; };
7134	template <> struct StructExtends<PhysicalDeviceSubpassShadingFeaturesHUAWEI, DeviceCreateInfo>{ enum { value = true }; };
7135	template <> struct StructExtends<PhysicalDeviceSubpassShadingPropertiesHUAWEI, PhysicalDeviceProperties2>{ enum { value = true }; };
7136
7137	//=== VK_HUAWEI_invocation_mask ===
7138	template <> struct StructExtends<PhysicalDeviceInvocationMaskFeaturesHUAWEI, PhysicalDeviceFeatures2>{ enum { value = true }; };
7139	template <> struct StructExtends<PhysicalDeviceInvocationMaskFeaturesHUAWEI, DeviceCreateInfo>{ enum { value = true }; };
7140
7141	//=== VK_NV_external_memory_rdma ===
7142	template <> struct StructExtends<PhysicalDeviceExternalMemoryRDMAFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
7143	template <> struct StructExtends<PhysicalDeviceExternalMemoryRDMAFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
7144
7145	//=== VK_EXT_pipeline_properties ===
7146	template <> struct StructExtends<PhysicalDevicePipelinePropertiesFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7147	template <> struct StructExtends<PhysicalDevicePipelinePropertiesFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7148
7149	//=== VK_EXT_multisampled_render_to_single_sampled ===
7150	template <> struct StructExtends<PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7151	template <> struct StructExtends<PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7152	template <> struct StructExtends<SubpassResolvePerformanceQueryEXT, FormatProperties2>{ enum { value = true }; };
7153	template <> struct StructExtends<MultisampledRenderToSingleSampledInfoEXT, SubpassDescription2>{ enum { value = true }; };
7154	template <> struct StructExtends<MultisampledRenderToSingleSampledInfoEXT, RenderingInfo>{ enum { value = true }; };
7155
7156	//=== VK_EXT_extended_dynamic_state2 ===
7157	template <> struct StructExtends<PhysicalDeviceExtendedDynamicState2FeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7158	template <> struct StructExtends<PhysicalDeviceExtendedDynamicState2FeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7159
7160	//=== VK_EXT_color_write_enable ===
7161	template <> struct StructExtends<PhysicalDeviceColorWriteEnableFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7162	template <> struct StructExtends<PhysicalDeviceColorWriteEnableFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7163	template <> struct StructExtends<PipelineColorWriteCreateInfoEXT, PipelineColorBlendStateCreateInfo>{ enum { value = true }; };
7164
7165	//=== VK_EXT_primitives_generated_query ===
7166	template <> struct StructExtends<PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7167	template <> struct StructExtends<PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7168
7169	//=== VK_KHR_ray_tracing_maintenance1 ===
7170	template <> struct StructExtends<PhysicalDeviceRayTracingMaintenance1FeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
7171	template <> struct StructExtends<PhysicalDeviceRayTracingMaintenance1FeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
7172
7173	//=== VK_EXT_image_view_min_lod ===
7174	template <> struct StructExtends<PhysicalDeviceImageViewMinLodFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7175	template <> struct StructExtends<PhysicalDeviceImageViewMinLodFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7176	template <> struct StructExtends<ImageViewMinLodCreateInfoEXT, ImageViewCreateInfo>{ enum { value = true }; };
7177
7178	//=== VK_EXT_multi_draw ===
7179	template <> struct StructExtends<PhysicalDeviceMultiDrawFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7180	template <> struct StructExtends<PhysicalDeviceMultiDrawFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7181	template <> struct StructExtends<PhysicalDeviceMultiDrawPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
7182
7183	//=== VK_EXT_image_2d_view_of_3d ===
7184	template <> struct StructExtends<PhysicalDeviceImage2DViewOf3DFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7185	template <> struct StructExtends<PhysicalDeviceImage2DViewOf3DFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7186
7187	//=== VK_EXT_opacity_micromap ===
7188	template <> struct StructExtends<PhysicalDeviceOpacityMicromapFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7189	template <> struct StructExtends<PhysicalDeviceOpacityMicromapFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7190	template <> struct StructExtends<PhysicalDeviceOpacityMicromapPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
7191	template <> struct StructExtends<AccelerationStructureTrianglesOpacityMicromapEXT, AccelerationStructureGeometryTrianglesDataKHR>{ enum { value = true }; };
7192
7193	//=== VK_EXT_border_color_swizzle ===
7194	template <> struct StructExtends<PhysicalDeviceBorderColorSwizzleFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7195	template <> struct StructExtends<PhysicalDeviceBorderColorSwizzleFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7196	template <> struct StructExtends<SamplerBorderColorComponentMappingCreateInfoEXT, SamplerCreateInfo>{ enum { value = true }; };
7197
7198	//=== VK_EXT_pageable_device_local_memory ===
7199	template <> struct StructExtends<PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7200	template <> struct StructExtends<PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7201
7202	//=== VK_VALVE_descriptor_set_host_mapping ===
7203	template <> struct StructExtends<PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, PhysicalDeviceFeatures2>{ enum { value = true }; };
7204	template <> struct StructExtends<PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, DeviceCreateInfo>{ enum { value = true }; };
7205
7206	//=== VK_EXT_depth_clamp_zero_one ===
7207	template <> struct StructExtends<PhysicalDeviceDepthClampZeroOneFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7208	template <> struct StructExtends<PhysicalDeviceDepthClampZeroOneFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7209
7210	//=== VK_EXT_non_seamless_cube_map ===
7211	template <> struct StructExtends<PhysicalDeviceNonSeamlessCubeMapFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7212	template <> struct StructExtends<PhysicalDeviceNonSeamlessCubeMapFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7213
7214	//=== VK_QCOM_fragment_density_map_offset ===
7215	template <> struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, PhysicalDeviceFeatures2>{ enum { value = true }; };
7216	template <> struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, DeviceCreateInfo>{ enum { value = true }; };
7217	template <> struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, PhysicalDeviceProperties2>{ enum { value = true }; };
7218	template <> struct StructExtends<SubpassFragmentDensityMapOffsetEndInfoQCOM, SubpassEndInfo>{ enum { value = true }; };
7219
7220	//=== VK_NV_copy_memory_indirect ===
7221	template <> struct StructExtends<PhysicalDeviceCopyMemoryIndirectFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
7222	template <> struct StructExtends<PhysicalDeviceCopyMemoryIndirectFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
7223	template <> struct StructExtends<PhysicalDeviceCopyMemoryIndirectPropertiesNV, PhysicalDeviceProperties2>{ enum { value = true }; };
7224
7225	//=== VK_NV_memory_decompression ===
7226	template <> struct StructExtends<PhysicalDeviceMemoryDecompressionFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
7227	template <> struct StructExtends<PhysicalDeviceMemoryDecompressionFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
7228	template <> struct StructExtends<PhysicalDeviceMemoryDecompressionPropertiesNV, PhysicalDeviceProperties2>{ enum { value = true }; };
7229
7230	//=== VK_NV_linear_color_attachment ===
7231	template <> struct StructExtends<PhysicalDeviceLinearColorAttachmentFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
7232	template <> struct StructExtends<PhysicalDeviceLinearColorAttachmentFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
7233
7234	//=== VK_EXT_image_compression_control_swapchain ===
7235	template <> struct StructExtends<PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7236	template <> struct StructExtends<PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7237
7238	//=== VK_QCOM_image_processing ===
7239	template <> struct StructExtends<ImageViewSampleWeightCreateInfoQCOM, ImageViewCreateInfo>{ enum { value = true }; };
7240	template <> struct StructExtends<PhysicalDeviceImageProcessingFeaturesQCOM, PhysicalDeviceFeatures2>{ enum { value = true }; };
7241	template <> struct StructExtends<PhysicalDeviceImageProcessingFeaturesQCOM, DeviceCreateInfo>{ enum { value = true }; };
7242	template <> struct StructExtends<PhysicalDeviceImageProcessingPropertiesQCOM, PhysicalDeviceProperties2>{ enum { value = true }; };
7243
7244	//=== VK_EXT_extended_dynamic_state3 ===
7245	template <> struct StructExtends<PhysicalDeviceExtendedDynamicState3FeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7246	template <> struct StructExtends<PhysicalDeviceExtendedDynamicState3FeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7247	template <> struct StructExtends<PhysicalDeviceExtendedDynamicState3PropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
7248
7249	//=== VK_EXT_subpass_merge_feedback ===
7250	template <> struct StructExtends<PhysicalDeviceSubpassMergeFeedbackFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7251	template <> struct StructExtends<PhysicalDeviceSubpassMergeFeedbackFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7252	template <> struct StructExtends<RenderPassCreationControlEXT, RenderPassCreateInfo2>{ enum { value = true }; };
7253	template <> struct StructExtends<RenderPassCreationControlEXT, SubpassDescription2>{ enum { value = true }; };
7254	template <> struct StructExtends<RenderPassCreationFeedbackCreateInfoEXT, RenderPassCreateInfo2>{ enum { value = true }; };
7255	template <> struct StructExtends<RenderPassSubpassFeedbackCreateInfoEXT, SubpassDescription2>{ enum { value = true }; };
7256
7257	//=== VK_LUNARG_direct_driver_loading ===
7258	template <> struct StructExtends<DirectDriverLoadingListLUNARG, InstanceCreateInfo>{ enum { value = true }; };
7259
7260	//=== VK_EXT_shader_module_identifier ===
7261	template <> struct StructExtends<PhysicalDeviceShaderModuleIdentifierFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7262	template <> struct StructExtends<PhysicalDeviceShaderModuleIdentifierFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7263	template <> struct StructExtends<PhysicalDeviceShaderModuleIdentifierPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
7264	template <> struct StructExtends<PipelineShaderStageModuleIdentifierCreateInfoEXT, PipelineShaderStageCreateInfo>{ enum { value = true }; };
7265
7266	//=== VK_EXT_rasterization_order_attachment_access ===
7267	template <> struct StructExtends<PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7268	template <> struct StructExtends<PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7269
7270	//=== VK_NV_optical_flow ===
7271	template <> struct StructExtends<PhysicalDeviceOpticalFlowFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
7272	template <> struct StructExtends<PhysicalDeviceOpticalFlowFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
7273	template <> struct StructExtends<PhysicalDeviceOpticalFlowPropertiesNV, PhysicalDeviceProperties2>{ enum { value = true }; };
7274	template <> struct StructExtends<OpticalFlowImageFormatInfoNV, PhysicalDeviceImageFormatInfo2>{ enum { value = true }; };
7275	template <> struct StructExtends<OpticalFlowImageFormatInfoNV, ImageCreateInfo>{ enum { value = true }; };
7276	template <> struct StructExtends<OpticalFlowSessionCreatePrivateDataInfoNV, OpticalFlowSessionCreateInfoNV>{ enum { value = true }; };
7277
7278	//=== VK_EXT_legacy_dithering ===
7279	template <> struct StructExtends<PhysicalDeviceLegacyDitheringFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7280	template <> struct StructExtends<PhysicalDeviceLegacyDitheringFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7281
7282	//=== VK_EXT_pipeline_protected_access ===
7283	template <> struct StructExtends<PhysicalDevicePipelineProtectedAccessFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7284	template <> struct StructExtends<PhysicalDevicePipelineProtectedAccessFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7285
7286	//=== VK_QCOM_tile_properties ===
7287	template <> struct StructExtends<PhysicalDeviceTilePropertiesFeaturesQCOM, PhysicalDeviceFeatures2>{ enum { value = true }; };
7288	template <> struct StructExtends<PhysicalDeviceTilePropertiesFeaturesQCOM, DeviceCreateInfo>{ enum { value = true }; };
7289
7290	//=== VK_SEC_amigo_profiling ===
7291	template <> struct StructExtends<PhysicalDeviceAmigoProfilingFeaturesSEC, PhysicalDeviceFeatures2>{ enum { value = true }; };
7292	template <> struct StructExtends<PhysicalDeviceAmigoProfilingFeaturesSEC, DeviceCreateInfo>{ enum { value = true }; };
7293	template <> struct StructExtends<AmigoProfilingSubmitInfoSEC, SubmitInfo>{ enum { value = true }; };
7294
7295	//=== VK_QCOM_multiview_per_view_viewports ===
7296	template <> struct StructExtends<PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, PhysicalDeviceFeatures2>{ enum { value = true }; };
7297	template <> struct StructExtends<PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, DeviceCreateInfo>{ enum { value = true }; };
7298
7299	//=== VK_NV_ray_tracing_invocation_reorder ===
7300	template <> struct StructExtends<PhysicalDeviceRayTracingInvocationReorderPropertiesNV, PhysicalDeviceProperties2>{ enum { value = true }; };
7301	template <> struct StructExtends<PhysicalDeviceRayTracingInvocationReorderFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
7302	template <> struct StructExtends<PhysicalDeviceRayTracingInvocationReorderFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
7303
7304	//=== VK_EXT_mutable_descriptor_type ===
7305	template <> struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
7306	template <> struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
7307	template <> struct StructExtends<MutableDescriptorTypeCreateInfoEXT, DescriptorSetLayoutCreateInfo>{ enum { value = true }; };
7308	template <> struct StructExtends<MutableDescriptorTypeCreateInfoEXT, DescriptorPoolCreateInfo>{ enum { value = true }; };
7309
7310	//=== VK_ARM_shader_core_builtins ===
7311	template <> struct StructExtends<PhysicalDeviceShaderCoreBuiltinsFeaturesARM, PhysicalDeviceFeatures2>{ enum { value = true }; };
7312	template <> struct StructExtends<PhysicalDeviceShaderCoreBuiltinsFeaturesARM, DeviceCreateInfo>{ enum { value = true }; };
7313	template <> struct StructExtends<PhysicalDeviceShaderCoreBuiltinsPropertiesARM, PhysicalDeviceProperties2>{ enum { value = true }; };
7314
7315	#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
7316
7317	#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
7318	class DynamicLoader
7319	{
7320	public:
7321	# ifdef VULKAN_HPP_NO_EXCEPTIONS
7322	DynamicLoader( std::string const & vulkanLibraryName = {} ) VULKAN_HPP_NOEXCEPT
7323	# else
7324	DynamicLoader( std::string const & vulkanLibraryName = {} )
7325	# endif
7326	{
7327	if ( !vulkanLibraryName.empty() )
7328	{
7329	# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined(__Fuchsia__)
7330	m_library = dlopen( file: vulkanLibraryName.c_str(), RTLD_NOW | RTLD_LOCAL );
7331	# elif defined( _WIN32 )
7332	m_library = ::LoadLibraryA( vulkanLibraryName.c_str() );
7333	# else
7334	# error unsupported platform
7335	# endif
7336	}
7337	else
7338	{
7339	# if defined( __unix__ ) || defined( __QNXNTO__ ) || defined(__Fuchsia__)
7340	m_library = dlopen( file: "libvulkan.so", RTLD_NOW | RTLD_LOCAL );
7341	if ( m_library == nullptr )
7342	{
7343	m_library = dlopen( file: "libvulkan.so.1", RTLD_NOW | RTLD_LOCAL );
7344	}
7345	# elif defined( __APPLE__ )
7346	m_library = dlopen( "libvulkan.dylib", RTLD_NOW | RTLD_LOCAL );
7347	# elif defined( _WIN32 )
7348	m_library = ::LoadLibraryA( "vulkan-1.dll" );
7349	# else
7350	# error unsupported platform
7351	# endif
7352	}
7353
7354	#ifndef VULKAN_HPP_NO_EXCEPTIONS
7355	if ( m_library == nullptr )
7356	{
7357	// NOTE there should be an InitializationFailedError, but msvc insists on the symbol does not exist within the scope of this function.
7358	throw std::runtime_error( "Failed to load vulkan library!" );
7359	}
7360	#endif
7361	}
7362
7363	DynamicLoader( DynamicLoader const & ) = delete;
7364
7365	DynamicLoader( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT : m_library(other.m_library)
7366	{
7367	other.m_library = nullptr;
7368	}
7369
7370	DynamicLoader &operator=( DynamicLoader const & ) = delete;
7371
7372	DynamicLoader &operator=( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT
7373	{
7374	std::swap(x&: m_library, y&: other.m_library);
7375	return *this;
7376	}
7377
7378	~DynamicLoader() VULKAN_HPP_NOEXCEPT
7379	{
7380	if ( m_library )
7381	{
7382	# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined(__Fuchsia__)
7383	dlclose( handle: m_library );
7384	# elif defined( _WIN32 )
7385	::FreeLibrary( m_library );
7386	# else
7387	# error unsupported platform
7388	# endif
7389	}
7390	}
7391
7392	template <typename T>
7393	T getProcAddress( const char* function ) const VULKAN_HPP_NOEXCEPT
7394	{
7395	# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined(__Fuchsia__)
7396	return (T)dlsym( handle: m_library, name: function );
7397	# elif defined( _WIN32 )
7398	return (T)::GetProcAddress( m_library, function );
7399	# else
7400	# error unsupported platform
7401	# endif
7402	}
7403
7404	bool success() const VULKAN_HPP_NOEXCEPT { return m_library != nullptr; }
7405
7406	private:
7407	# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined(__Fuchsia__)
7408	void * m_library;
7409	# elif defined( _WIN32 )
7410	::HINSTANCE m_library;
7411	# else
7412	# error unsupported platform
7413	# endif
7414	};
7415	#endif
7416
7417
7418	using PFN_dummy = void ( * )();
7419
7420	class DispatchLoaderDynamic : public DispatchLoaderBase
7421	{
7422	public:
7423
7424	//=== VK_VERSION_1_0 ===
7425	PFN_vkCreateInstance vkCreateInstance = 0;
7426	PFN_vkDestroyInstance vkDestroyInstance = 0;
7427	PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0;
7428	PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures = 0;
7429	PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties = 0;
7430	PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties = 0;
7431	PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0;
7432	PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0;
7433	PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0;
7434	PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0;
7435	PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0;
7436	PFN_vkCreateDevice vkCreateDevice = 0;
7437	PFN_vkDestroyDevice vkDestroyDevice = 0;
7438	PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0;
7439	PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0;
7440	PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0;
7441	PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0;
7442	PFN_vkGetDeviceQueue vkGetDeviceQueue = 0;
7443	PFN_vkQueueSubmit vkQueueSubmit = 0;
7444	PFN_vkQueueWaitIdle vkQueueWaitIdle = 0;
7445	PFN_vkDeviceWaitIdle vkDeviceWaitIdle = 0;
7446	PFN_vkAllocateMemory vkAllocateMemory = 0;
7447	PFN_vkFreeMemory vkFreeMemory = 0;
7448	PFN_vkMapMemory vkMapMemory = 0;
7449	PFN_vkUnmapMemory vkUnmapMemory = 0;
7450	PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = 0;
7451	PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0;
7452	PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0;
7453	PFN_vkBindBufferMemory vkBindBufferMemory = 0;
7454	PFN_vkBindImageMemory vkBindImageMemory = 0;
7455	PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0;
7456	PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0;
7457	PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements = 0;
7458	PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0;
7459	PFN_vkQueueBindSparse vkQueueBindSparse = 0;
7460	PFN_vkCreateFence vkCreateFence = 0;
7461	PFN_vkDestroyFence vkDestroyFence = 0;
7462	PFN_vkResetFences vkResetFences = 0;
7463	PFN_vkGetFenceStatus vkGetFenceStatus = 0;
7464	PFN_vkWaitForFences vkWaitForFences = 0;
7465	PFN_vkCreateSemaphore vkCreateSemaphore = 0;
7466	PFN_vkDestroySemaphore vkDestroySemaphore = 0;
7467	PFN_vkCreateEvent vkCreateEvent = 0;
7468	PFN_vkDestroyEvent vkDestroyEvent = 0;
7469	PFN_vkGetEventStatus vkGetEventStatus = 0;
7470	PFN_vkSetEvent vkSetEvent = 0;
7471	PFN_vkResetEvent vkResetEvent = 0;
7472	PFN_vkCreateQueryPool vkCreateQueryPool = 0;
7473	PFN_vkDestroyQueryPool vkDestroyQueryPool = 0;
7474	PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0;
7475	PFN_vkCreateBuffer vkCreateBuffer = 0;
7476	PFN_vkDestroyBuffer vkDestroyBuffer = 0;
7477	PFN_vkCreateBufferView vkCreateBufferView = 0;
7478	PFN_vkDestroyBufferView vkDestroyBufferView = 0;
7479	PFN_vkCreateImage vkCreateImage = 0;
7480	PFN_vkDestroyImage vkDestroyImage = 0;
7481	PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0;
7482	PFN_vkCreateImageView vkCreateImageView = 0;
7483	PFN_vkDestroyImageView vkDestroyImageView = 0;
7484	PFN_vkCreateShaderModule vkCreateShaderModule = 0;
7485	PFN_vkDestroyShaderModule vkDestroyShaderModule = 0;
7486	PFN_vkCreatePipelineCache vkCreatePipelineCache = 0;
7487	PFN_vkDestroyPipelineCache vkDestroyPipelineCache = 0;
7488	PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0;
7489	PFN_vkMergePipelineCaches vkMergePipelineCaches = 0;
7490	PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0;
7491	PFN_vkCreateComputePipelines vkCreateComputePipelines = 0;
7492	PFN_vkDestroyPipeline vkDestroyPipeline = 0;
7493	PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0;
7494	PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = 0;
7495	PFN_vkCreateSampler vkCreateSampler = 0;
7496	PFN_vkDestroySampler vkDestroySampler = 0;
7497	PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0;
7498	PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0;
7499	PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0;
7500	PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0;
7501	PFN_vkResetDescriptorPool vkResetDescriptorPool = 0;
7502	PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0;
7503	PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0;
7504	PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0;
7505	PFN_vkCreateFramebuffer vkCreateFramebuffer = 0;
7506	PFN_vkDestroyFramebuffer vkDestroyFramebuffer = 0;
7507	PFN_vkCreateRenderPass vkCreateRenderPass = 0;
7508	PFN_vkDestroyRenderPass vkDestroyRenderPass = 0;
7509	PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0;
7510	PFN_vkCreateCommandPool vkCreateCommandPool = 0;
7511	PFN_vkDestroyCommandPool vkDestroyCommandPool = 0;
7512	PFN_vkResetCommandPool vkResetCommandPool = 0;
7513	PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0;
7514	PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0;
7515	PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0;
7516	PFN_vkEndCommandBuffer vkEndCommandBuffer = 0;
7517	PFN_vkResetCommandBuffer vkResetCommandBuffer = 0;
7518	PFN_vkCmdBindPipeline vkCmdBindPipeline = 0;
7519	PFN_vkCmdSetViewport vkCmdSetViewport = 0;
7520	PFN_vkCmdSetScissor vkCmdSetScissor = 0;
7521	PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0;
7522	PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0;
7523	PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = 0;
7524	PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0;
7525	PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask = 0;
7526	PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = 0;
7527	PFN_vkCmdSetStencilReference vkCmdSetStencilReference = 0;
7528	PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0;
7529	PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0;
7530	PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0;
7531	PFN_vkCmdDraw vkCmdDraw = 0;
7532	PFN_vkCmdDrawIndexed vkCmdDrawIndexed = 0;
7533	PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0;
7534	PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect = 0;
7535	PFN_vkCmdDispatch vkCmdDispatch = 0;
7536	PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect = 0;
7537	PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0;
7538	PFN_vkCmdCopyImage vkCmdCopyImage = 0;
7539	PFN_vkCmdBlitImage vkCmdBlitImage = 0;
7540	PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0;
7541	PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer = 0;
7542	PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0;
7543	PFN_vkCmdFillBuffer vkCmdFillBuffer = 0;
7544	PFN_vkCmdClearColorImage vkCmdClearColorImage = 0;
7545	PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0;
7546	PFN_vkCmdClearAttachments vkCmdClearAttachments = 0;
7547	PFN_vkCmdResolveImage vkCmdResolveImage = 0;
7548	PFN_vkCmdSetEvent vkCmdSetEvent = 0;
7549	PFN_vkCmdResetEvent vkCmdResetEvent = 0;
7550	PFN_vkCmdWaitEvents vkCmdWaitEvents = 0;
7551	PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = 0;
7552	PFN_vkCmdBeginQuery vkCmdBeginQuery = 0;
7553	PFN_vkCmdEndQuery vkCmdEndQuery = 0;
7554	PFN_vkCmdResetQueryPool vkCmdResetQueryPool = 0;
7555	PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0;
7556	PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = 0;
7557	PFN_vkCmdPushConstants vkCmdPushConstants = 0;
7558	PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0;
7559	PFN_vkCmdNextSubpass vkCmdNextSubpass = 0;
7560	PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0;
7561	PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0;
7562
7563	//=== VK_VERSION_1_1 ===
7564	PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0;
7565	PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0;
7566	PFN_vkBindImageMemory2 vkBindImageMemory2 = 0;
7567	PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0;
7568	PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0;
7569	PFN_vkCmdDispatchBase vkCmdDispatchBase = 0;
7570	PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0;
7571	PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = 0;
7572	PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0;
7573	PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 = 0;
7574	PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 = 0;
7575	PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0;
7576	PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 = 0;
7577	PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 = 0;
7578	PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0;
7579	PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = 0;
7580	PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0;
7581	PFN_vkTrimCommandPool vkTrimCommandPool = 0;
7582	PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = 0;
7583	PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = 0;
7584	PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion = 0;
7585	PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0;
7586	PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = 0;
7587	PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0;
7588	PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties = 0;
7589	PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties = 0;
7590	PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties = 0;
7591	PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = 0;
7592
7593	//=== VK_VERSION_1_2 ===
7594	PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount = 0;
7595	PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount = 0;
7596	PFN_vkCreateRenderPass2 vkCreateRenderPass2 = 0;
7597	PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2 = 0;
7598	PFN_vkCmdNextSubpass2 vkCmdNextSubpass2 = 0;
7599	PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2 = 0;
7600	PFN_vkResetQueryPool vkResetQueryPool = 0;
7601	PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue = 0;
7602	PFN_vkWaitSemaphores vkWaitSemaphores = 0;
7603	PFN_vkSignalSemaphore vkSignalSemaphore = 0;
7604	PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress = 0;
7605	PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress = 0;
7606	PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress = 0;
7607
7608	//=== VK_VERSION_1_3 ===
7609	PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties = 0;
7610	PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot = 0;
7611	PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot = 0;
7612	PFN_vkSetPrivateData vkSetPrivateData = 0;
7613	PFN_vkGetPrivateData vkGetPrivateData = 0;
7614	PFN_vkCmdSetEvent2 vkCmdSetEvent2 = 0;
7615	PFN_vkCmdResetEvent2 vkCmdResetEvent2 = 0;
7616	PFN_vkCmdWaitEvents2 vkCmdWaitEvents2 = 0;
7617	PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2 = 0;
7618	PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2 = 0;
7619	PFN_vkQueueSubmit2 vkQueueSubmit2 = 0;
7620	PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2 = 0;
7621	PFN_vkCmdCopyImage2 vkCmdCopyImage2 = 0;
7622	PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2 = 0;
7623	PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2 = 0;
7624	PFN_vkCmdBlitImage2 vkCmdBlitImage2 = 0;
7625	PFN_vkCmdResolveImage2 vkCmdResolveImage2 = 0;
7626	PFN_vkCmdBeginRendering vkCmdBeginRendering = 0;
7627	PFN_vkCmdEndRendering vkCmdEndRendering = 0;
7628	PFN_vkCmdSetCullMode vkCmdSetCullMode = 0;
7629	PFN_vkCmdSetFrontFace vkCmdSetFrontFace = 0;
7630	PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology = 0;
7631	PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount = 0;
7632	PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount = 0;
7633	PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2 = 0;
7634	PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable = 0;
7635	PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable = 0;
7636	PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp = 0;
7637	PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable = 0;
7638	PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable = 0;
7639	PFN_vkCmdSetStencilOp vkCmdSetStencilOp = 0;
7640	PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable = 0;
7641	PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable = 0;
7642	PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable = 0;
7643	PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements = 0;
7644	PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements = 0;
7645	PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements = 0;
7646
7647	//=== VK_KHR_surface ===
7648	PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0;
7649	PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = 0;
7650	PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0;
7651	PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = 0;
7652	PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0;
7653
7654	//=== VK_KHR_swapchain ===
7655	PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = 0;
7656	PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = 0;
7657	PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0;
7658	PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0;
7659	PFN_vkQueuePresentKHR vkQueuePresentKHR = 0;
7660	PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0;
7661	PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = 0;
7662	PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0;
7663	PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0;
7664
7665	//=== VK_KHR_display ===
7666	PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR = 0;
7667	PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0;
7668	PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0;
7669	PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0;
7670	PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0;
7671	PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0;
7672	PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0;
7673
7674	//=== VK_KHR_display_swapchain ===
7675	PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0;
7676
7677	#if defined( VK_USE_PLATFORM_XLIB_KHR )
7678	//=== VK_KHR_xlib_surface ===
7679	PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0;
7680	PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0;
7681	#else
7682	PFN_dummy vkCreateXlibSurfaceKHR_placeholder = 0;
7683	PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder = 0;
7684	#endif /*VK_USE_PLATFORM_XLIB_KHR*/
7685
7686	#if defined( VK_USE_PLATFORM_XCB_KHR )
7687	//=== VK_KHR_xcb_surface ===
7688	PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0;
7689	PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0;
7690	#else
7691	PFN_dummy vkCreateXcbSurfaceKHR_placeholder = 0;
7692	PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder = 0;
7693	#endif /*VK_USE_PLATFORM_XCB_KHR*/
7694
7695	#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
7696	//=== VK_KHR_wayland_surface ===
7697	PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0;
7698	PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0;
7699	#else
7700	PFN_dummy vkCreateWaylandSurfaceKHR_placeholder = 0;
7701	PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder = 0;
7702	#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
7703
7704	#if defined( VK_USE_PLATFORM_ANDROID_KHR )
7705	//=== VK_KHR_android_surface ===
7706	PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0;
7707	#else
7708	PFN_dummy vkCreateAndroidSurfaceKHR_placeholder = 0;
7709	#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
7710
7711	#if defined( VK_USE_PLATFORM_WIN32_KHR )
7712	//=== VK_KHR_win32_surface ===
7713	PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0;
7714	PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0;
7715	#else
7716	PFN_dummy vkCreateWin32SurfaceKHR_placeholder = 0;
7717	PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder = 0;
7718	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
7719
7720	//=== VK_EXT_debug_report ===
7721	PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0;
7722	PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0;
7723	PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0;
7724
7725	//=== VK_EXT_debug_marker ===
7726	PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0;
7727	PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0;
7728	PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT = 0;
7729	PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = 0;
7730	PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = 0;
7731
7732	//=== VK_KHR_video_queue ===
7733	PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR = 0;
7734	PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR = 0;
7735	PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR = 0;
7736	PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR = 0;
7737	PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR = 0;
7738	PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR = 0;
7739	PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR = 0;
7740	PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR = 0;
7741	PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR = 0;
7742	PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR = 0;
7743	PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR = 0;
7744	PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR = 0;
7745
7746	//=== VK_KHR_video_decode_queue ===
7747	PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR = 0;
7748
7749	//=== VK_EXT_transform_feedback ===
7750	PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = 0;
7751	PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT = 0;
7752	PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT = 0;
7753	PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT = 0;
7754	PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT = 0;
7755	PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT = 0;
7756
7757	//=== VK_NVX_binary_import ===
7758	PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX = 0;
7759	PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX = 0;
7760	PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX = 0;
7761	PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX = 0;
7762	PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0;
7763
7764	//=== VK_NVX_image_view_handle ===
7765	PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0;
7766	PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0;
7767
7768	//=== VK_AMD_draw_indirect_count ===
7769	PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0;
7770	PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = 0;
7771
7772	//=== VK_AMD_shader_info ===
7773	PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = 0;
7774
7775	//=== VK_KHR_dynamic_rendering ===
7776	PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR = 0;
7777	PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR = 0;
7778
7779	#if defined( VK_USE_PLATFORM_GGP )
7780	//=== VK_GGP_stream_descriptor_surface ===
7781	PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0;
7782	#else
7783	PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder = 0;
7784	#endif /*VK_USE_PLATFORM_GGP*/
7785
7786	//=== VK_NV_external_memory_capabilities ===
7787	PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 0;
7788
7789	#if defined( VK_USE_PLATFORM_WIN32_KHR )
7790	//=== VK_NV_external_memory_win32 ===
7791	PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0;
7792	#else
7793	PFN_dummy vkGetMemoryWin32HandleNV_placeholder = 0;
7794	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
7795
7796	//=== VK_KHR_get_physical_device_properties2 ===
7797	PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = 0;
7798	PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0;
7799	PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR = 0;
7800	PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR = 0;
7801	PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0;
7802	PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = 0;
7803	PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0;
7804
7805	//=== VK_KHR_device_group ===
7806	PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = 0;
7807	PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0;
7808	PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR = 0;
7809
7810	#if defined( VK_USE_PLATFORM_VI_NN )
7811	//=== VK_NN_vi_surface ===
7812	PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0;
7813	#else
7814	PFN_dummy vkCreateViSurfaceNN_placeholder = 0;
7815	#endif /*VK_USE_PLATFORM_VI_NN*/
7816
7817	//=== VK_KHR_maintenance1 ===
7818	PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0;
7819
7820	//=== VK_KHR_device_group_creation ===
7821	PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0;
7822
7823	//=== VK_KHR_external_memory_capabilities ===
7824	PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR = 0;
7825
7826	#if defined( VK_USE_PLATFORM_WIN32_KHR )
7827	//=== VK_KHR_external_memory_win32 ===
7828	PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0;
7829	PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0;
7830	#else
7831	PFN_dummy vkGetMemoryWin32HandleKHR_placeholder = 0;
7832	PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder = 0;
7833	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
7834
7835	//=== VK_KHR_external_memory_fd ===
7836	PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = 0;
7837	PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR = 0;
7838
7839	//=== VK_KHR_external_semaphore_capabilities ===
7840	PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 0;
7841
7842	#if defined( VK_USE_PLATFORM_WIN32_KHR )
7843	//=== VK_KHR_external_semaphore_win32 ===
7844	PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0;
7845	PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0;
7846	#else
7847	PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder = 0;
7848	PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder = 0;
7849	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
7850
7851	//=== VK_KHR_external_semaphore_fd ===
7852	PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0;
7853	PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0;
7854
7855	//=== VK_KHR_push_descriptor ===
7856	PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR = 0;
7857	PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR = 0;
7858
7859	//=== VK_EXT_conditional_rendering ===
7860	PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = 0;
7861	PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT = 0;
7862
7863	//=== VK_KHR_descriptor_update_template ===
7864	PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = 0;
7865	PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR = 0;
7866	PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0;
7867
7868	//=== VK_NV_clip_space_w_scaling ===
7869	PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0;
7870
7871	//=== VK_EXT_direct_mode_display ===
7872	PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0;
7873
7874	#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
7875	//=== VK_EXT_acquire_xlib_display ===
7876	PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0;
7877	PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0;
7878	#else
7879	PFN_dummy vkAcquireXlibDisplayEXT_placeholder = 0;
7880	PFN_dummy vkGetRandROutputDisplayEXT_placeholder = 0;
7881	#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
7882
7883	//=== VK_EXT_display_surface_counter ===
7884	PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0;
7885
7886	//=== VK_EXT_display_control ===
7887	PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0;
7888	PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0;
7889	PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0;
7890	PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = 0;
7891
7892	//=== VK_GOOGLE_display_timing ===
7893	PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0;
7894	PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0;
7895
7896	//=== VK_EXT_discard_rectangles ===
7897	PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0;
7898
7899	//=== VK_EXT_hdr_metadata ===
7900	PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0;
7901
7902	//=== VK_KHR_create_renderpass2 ===
7903	PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 0;
7904	PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = 0;
7905	PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR = 0;
7906	PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR = 0;
7907
7908	//=== VK_KHR_shared_presentable_image ===
7909	PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0;
7910
7911	//=== VK_KHR_external_fence_capabilities ===
7912	PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR = 0;
7913
7914	#if defined( VK_USE_PLATFORM_WIN32_KHR )
7915	//=== VK_KHR_external_fence_win32 ===
7916	PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0;
7917	PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0;
7918	#else
7919	PFN_dummy vkImportFenceWin32HandleKHR_placeholder = 0;
7920	PFN_dummy vkGetFenceWin32HandleKHR_placeholder = 0;
7921	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
7922
7923	//=== VK_KHR_external_fence_fd ===
7924	PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0;
7925	PFN_vkGetFenceFdKHR vkGetFenceFdKHR = 0;
7926
7927	//=== VK_KHR_performance_query ===
7928	PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0;
7929	PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0;
7930	PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0;
7931	PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR = 0;
7932
7933	//=== VK_KHR_get_surface_capabilities2 ===
7934	PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = 0;
7935	PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = 0;
7936
7937	//=== VK_KHR_get_display_properties2 ===
7938	PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR = 0;
7939	PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0;
7940	PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0;
7941	PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0;
7942
7943	#if defined( VK_USE_PLATFORM_IOS_MVK )
7944	//=== VK_MVK_ios_surface ===
7945	PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0;
7946	#else
7947	PFN_dummy vkCreateIOSSurfaceMVK_placeholder = 0;
7948	#endif /*VK_USE_PLATFORM_IOS_MVK*/
7949
7950	#if defined( VK_USE_PLATFORM_MACOS_MVK )
7951	//=== VK_MVK_macos_surface ===
7952	PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0;
7953	#else
7954	PFN_dummy vkCreateMacOSSurfaceMVK_placeholder = 0;
7955	#endif /*VK_USE_PLATFORM_MACOS_MVK*/
7956
7957	//=== VK_EXT_debug_utils ===
7958	PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0;
7959	PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0;
7960	PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT = 0;
7961	PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = 0;
7962	PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = 0;
7963	PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0;
7964	PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0;
7965	PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0;
7966	PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0;
7967	PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0;
7968	PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0;
7969
7970	#if defined( VK_USE_PLATFORM_ANDROID_KHR )
7971	//=== VK_ANDROID_external_memory_android_hardware_buffer ===
7972	PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0;
7973	PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0;
7974	#else
7975	PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder = 0;
7976	PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0;
7977	#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
7978
7979	//=== VK_EXT_sample_locations ===
7980	PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0;
7981	PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0;
7982
7983	//=== VK_KHR_get_memory_requirements2 ===
7984	PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = 0;
7985	PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0;
7986	PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = 0;
7987
7988	//=== VK_KHR_acceleration_structure ===
7989	PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR = 0;
7990	PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR = 0;
7991	PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR = 0;
7992	PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR = 0;
7993	PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR = 0;
7994	PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR = 0;
7995	PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR = 0;
7996	PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR = 0;
7997	PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR = 0;
7998	PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR = 0;
7999	PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR = 0;
8000	PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR = 0;
8001	PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR = 0;
8002	PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR = 0;
8003	PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR = 0;
8004	PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR = 0;
8005
8006	//=== VK_KHR_sampler_ycbcr_conversion ===
8007	PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0;
8008	PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0;
8009
8010	//=== VK_KHR_bind_memory2 ===
8011	PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0;
8012	PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0;
8013
8014	//=== VK_EXT_image_drm_format_modifier ===
8015	PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT = 0;
8016
8017	//=== VK_EXT_validation_cache ===
8018	PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT = 0;
8019	PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = 0;
8020	PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT = 0;
8021	PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0;
8022
8023	//=== VK_NV_shading_rate_image ===
8024	PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV = 0;
8025	PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = 0;
8026	PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV = 0;
8027
8028	//=== VK_NV_ray_tracing ===
8029	PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = 0;
8030	PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0;
8031	PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0;
8032	PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 0;
8033	PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV = 0;
8034	PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV = 0;
8035	PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV = 0;
8036	PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = 0;
8037	PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0;
8038	PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = 0;
8039	PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0;
8040	PFN_vkCompileDeferredNV vkCompileDeferredNV = 0;
8041
8042	//=== VK_KHR_maintenance3 ===
8043	PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0;
8044
8045	//=== VK_KHR_draw_indirect_count ===
8046	PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0;
8047	PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = 0;
8048
8049	//=== VK_EXT_external_memory_host ===
8050	PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0;
8051
8052	//=== VK_AMD_buffer_marker ===
8053	PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0;
8054
8055	//=== VK_EXT_calibrated_timestamps ===
8056	PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0;
8057	PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 0;
8058
8059	//=== VK_NV_mesh_shader ===
8060	PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV = 0;
8061	PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = 0;
8062	PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0;
8063
8064	//=== VK_NV_scissor_exclusive ===
8065	PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0;
8066
8067	//=== VK_NV_device_diagnostic_checkpoints ===
8068	PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV = 0;
8069	PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV = 0;
8070
8071	//=== VK_KHR_timeline_semaphore ===
8072	PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR = 0;
8073	PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = 0;
8074	PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = 0;
8075
8076	//=== VK_INTEL_performance_query ===
8077	PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL = 0;
8078	PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = 0;
8079	PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = 0;
8080	PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL = 0;
8081	PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = 0;
8082	PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0;
8083	PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = 0;
8084	PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL = 0;
8085	PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL = 0;
8086
8087	//=== VK_AMD_display_native_hdr ===
8088	PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = 0;
8089
8090	#if defined( VK_USE_PLATFORM_FUCHSIA )
8091	//=== VK_FUCHSIA_imagepipe_surface ===
8092	PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0;
8093	#else
8094	PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder = 0;
8095	#endif /*VK_USE_PLATFORM_FUCHSIA*/
8096
8097	#if defined( VK_USE_PLATFORM_METAL_EXT )
8098	//=== VK_EXT_metal_surface ===
8099	PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0;
8100	#else
8101	PFN_dummy vkCreateMetalSurfaceEXT_placeholder = 0;
8102	#endif /*VK_USE_PLATFORM_METAL_EXT*/
8103
8104	//=== VK_KHR_fragment_shading_rate ===
8105	PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR = 0;
8106	PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR = 0;
8107
8108	//=== VK_EXT_buffer_device_address ===
8109	PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0;
8110
8111	//=== VK_EXT_tooling_info ===
8112	PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT = 0;
8113
8114	//=== VK_KHR_present_wait ===
8115	PFN_vkWaitForPresentKHR vkWaitForPresentKHR = 0;
8116
8117	//=== VK_NV_cooperative_matrix ===
8118	PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 0;
8119
8120	//=== VK_NV_coverage_reduction_mode ===
8121	PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 0;
8122
8123	#if defined( VK_USE_PLATFORM_WIN32_KHR )
8124	//=== VK_EXT_full_screen_exclusive ===
8125	PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT = 0;
8126	PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT = 0;
8127	PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0;
8128	PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0;
8129	#else
8130	PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder = 0;
8131	PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder = 0;
8132	PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder = 0;
8133	PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder = 0;
8134	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
8135
8136	//=== VK_EXT_headless_surface ===
8137	PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT = 0;
8138
8139	//=== VK_KHR_buffer_device_address ===
8140	PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR = 0;
8141	PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR = 0;
8142	PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR = 0;
8143
8144	//=== VK_EXT_line_rasterization ===
8145	PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0;
8146
8147	//=== VK_EXT_host_query_reset ===
8148	PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = 0;
8149
8150	//=== VK_EXT_extended_dynamic_state ===
8151	PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT = 0;
8152	PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT = 0;
8153	PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT = 0;
8154	PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT = 0;
8155	PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT = 0;
8156	PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT = 0;
8157	PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT = 0;
8158	PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT = 0;
8159	PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT = 0;
8160	PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT = 0;
8161	PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT = 0;
8162	PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT = 0;
8163
8164	//=== VK_KHR_deferred_host_operations ===
8165	PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR = 0;
8166	PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR = 0;
8167	PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR = 0;
8168	PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR = 0;
8169	PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR = 0;
8170
8171	//=== VK_KHR_pipeline_executable_properties ===
8172	PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR = 0;
8173	PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = 0;
8174	PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0;
8175
8176	//=== VK_EXT_swapchain_maintenance1 ===
8177	PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT = 0;
8178
8179	//=== VK_NV_device_generated_commands ===
8180	PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV = 0;
8181	PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV = 0;
8182	PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV = 0;
8183	PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV = 0;
8184	PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV = 0;
8185	PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV = 0;
8186
8187	//=== VK_EXT_acquire_drm_display ===
8188	PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT = 0;
8189	PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT = 0;
8190
8191	//=== VK_EXT_private_data ===
8192	PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT = 0;
8193	PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT = 0;
8194	PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT = 0;
8195	PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT = 0;
8196
8197	#if defined( VK_ENABLE_BETA_EXTENSIONS )
8198	//=== VK_KHR_video_encode_queue ===
8199	PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR = 0;
8200	#else
8201	PFN_dummy vkCmdEncodeVideoKHR_placeholder = 0;
8202	#endif /*VK_ENABLE_BETA_EXTENSIONS*/
8203
8204	#if defined( VK_USE_PLATFORM_METAL_EXT )
8205	//=== VK_EXT_metal_objects ===
8206	PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT = 0;
8207	#else
8208	PFN_dummy vkExportMetalObjectsEXT_placeholder = 0;
8209	#endif /*VK_USE_PLATFORM_METAL_EXT*/
8210
8211	//=== VK_KHR_synchronization2 ===
8212	PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR = 0;
8213	PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR = 0;
8214	PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR = 0;
8215	PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR = 0;
8216	PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR = 0;
8217	PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR = 0;
8218	PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD = 0;
8219	PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV = 0;
8220
8221	//=== VK_EXT_descriptor_buffer ===
8222	PFN_vkGetDescriptorSetLayoutSizeEXT vkGetDescriptorSetLayoutSizeEXT = 0;
8223	PFN_vkGetDescriptorSetLayoutBindingOffsetEXT vkGetDescriptorSetLayoutBindingOffsetEXT = 0;
8224	PFN_vkGetDescriptorEXT vkGetDescriptorEXT = 0;
8225	PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT = 0;
8226	PFN_vkCmdSetDescriptorBufferOffsetsEXT vkCmdSetDescriptorBufferOffsetsEXT = 0;
8227	PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT vkCmdBindDescriptorBufferEmbeddedSamplersEXT = 0;
8228	PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT vkGetBufferOpaqueCaptureDescriptorDataEXT = 0;
8229	PFN_vkGetImageOpaqueCaptureDescriptorDataEXT vkGetImageOpaqueCaptureDescriptorDataEXT = 0;
8230	PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT vkGetImageViewOpaqueCaptureDescriptorDataEXT = 0;
8231	PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT = 0;
8232	PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = 0;
8233
8234	//=== VK_NV_fragment_shading_rate_enums ===
8235	PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV = 0;
8236
8237	//=== VK_EXT_mesh_shader ===
8238	PFN_vkCmdDrawMeshTasksEXT vkCmdDrawMeshTasksEXT = 0;
8239	PFN_vkCmdDrawMeshTasksIndirectEXT vkCmdDrawMeshTasksIndirectEXT = 0;
8240	PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT = 0;
8241
8242	//=== VK_KHR_copy_commands2 ===
8243	PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR = 0;
8244	PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR = 0;
8245	PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR = 0;
8246	PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR = 0;
8247	PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR = 0;
8248	PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR = 0;
8249
8250	//=== VK_EXT_image_compression_control ===
8251	PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT = 0;
8252
8253	//=== VK_EXT_device_fault ===
8254	PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT = 0;
8255
8256	#if defined( VK_USE_PLATFORM_WIN32_KHR )
8257	//=== VK_NV_acquire_winrt_display ===
8258	PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0;
8259	PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0;
8260	#else
8261	PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0;
8262	PFN_dummy vkGetWinrtDisplayNV_placeholder = 0;
8263	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
8264
8265	#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
8266	//=== VK_EXT_directfb_surface ===
8267	PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0;
8268	PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 0;
8269	#else
8270	PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder = 0;
8271	PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0;
8272	#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
8273
8274	//=== VK_KHR_ray_tracing_pipeline ===
8275	PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR = 0;
8276	PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR = 0;
8277	PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR = 0;
8278	PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 0;
8279	PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR = 0;
8280	PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR = 0;
8281	PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR = 0;
8282
8283	//=== VK_EXT_vertex_input_dynamic_state ===
8284	PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT = 0;
8285
8286	#if defined( VK_USE_PLATFORM_FUCHSIA )
8287	//=== VK_FUCHSIA_external_memory ===
8288	PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA = 0;
8289	PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA = 0;
8290	#else
8291	PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder = 0;
8292	PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder = 0;
8293	#endif /*VK_USE_PLATFORM_FUCHSIA*/
8294
8295	#if defined( VK_USE_PLATFORM_FUCHSIA )
8296	//=== VK_FUCHSIA_external_semaphore ===
8297	PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA = 0;
8298	PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA = 0;
8299	#else
8300	PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder = 0;
8301	PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder = 0;
8302	#endif /*VK_USE_PLATFORM_FUCHSIA*/
8303
8304	#if defined( VK_USE_PLATFORM_FUCHSIA )
8305	//=== VK_FUCHSIA_buffer_collection ===
8306	PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA = 0;
8307	PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA = 0;
8308	PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA = 0;
8309	PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA = 0;
8310	PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA = 0;
8311	#else
8312	PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder = 0;
8313	PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder = 0;
8314	PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder = 0;
8315	PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder = 0;
8316	PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder = 0;
8317	#endif /*VK_USE_PLATFORM_FUCHSIA*/
8318
8319	//=== VK_HUAWEI_subpass_shading ===
8320	PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 0;
8321	PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI = 0;
8322
8323	//=== VK_HUAWEI_invocation_mask ===
8324	PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI = 0;
8325
8326	//=== VK_NV_external_memory_rdma ===
8327	PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV = 0;
8328
8329	//=== VK_EXT_pipeline_properties ===
8330	PFN_vkGetPipelinePropertiesEXT vkGetPipelinePropertiesEXT = 0;
8331
8332	//=== VK_EXT_extended_dynamic_state2 ===
8333	PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT = 0;
8334	PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT = 0;
8335	PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT = 0;
8336	PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT = 0;
8337	PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT = 0;
8338
8339	#if defined( VK_USE_PLATFORM_SCREEN_QNX )
8340	//=== VK_QNX_screen_surface ===
8341	PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX = 0;
8342	PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX = 0;
8343	#else
8344	PFN_dummy vkCreateScreenSurfaceQNX_placeholder = 0;
8345	PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder = 0;
8346	#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
8347
8348	//=== VK_EXT_color_write_enable ===
8349	PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT = 0;
8350
8351	//=== VK_KHR_ray_tracing_maintenance1 ===
8352	PFN_vkCmdTraceRaysIndirect2KHR vkCmdTraceRaysIndirect2KHR = 0;
8353
8354	//=== VK_EXT_multi_draw ===
8355	PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT = 0;
8356	PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT = 0;
8357
8358	//=== VK_EXT_opacity_micromap ===
8359	PFN_vkCreateMicromapEXT vkCreateMicromapEXT = 0;
8360	PFN_vkDestroyMicromapEXT vkDestroyMicromapEXT = 0;
8361	PFN_vkCmdBuildMicromapsEXT vkCmdBuildMicromapsEXT = 0;
8362	PFN_vkBuildMicromapsEXT vkBuildMicromapsEXT = 0;
8363	PFN_vkCopyMicromapEXT vkCopyMicromapEXT = 0;
8364	PFN_vkCopyMicromapToMemoryEXT vkCopyMicromapToMemoryEXT = 0;
8365	PFN_vkCopyMemoryToMicromapEXT vkCopyMemoryToMicromapEXT = 0;
8366	PFN_vkWriteMicromapsPropertiesEXT vkWriteMicromapsPropertiesEXT = 0;
8367	PFN_vkCmdCopyMicromapEXT vkCmdCopyMicromapEXT = 0;
8368	PFN_vkCmdCopyMicromapToMemoryEXT vkCmdCopyMicromapToMemoryEXT = 0;
8369	PFN_vkCmdCopyMemoryToMicromapEXT vkCmdCopyMemoryToMicromapEXT = 0;
8370	PFN_vkCmdWriteMicromapsPropertiesEXT vkCmdWriteMicromapsPropertiesEXT = 0;
8371	PFN_vkGetDeviceMicromapCompatibilityEXT vkGetDeviceMicromapCompatibilityEXT = 0;
8372	PFN_vkGetMicromapBuildSizesEXT vkGetMicromapBuildSizesEXT = 0;
8373
8374	//=== VK_EXT_pageable_device_local_memory ===
8375	PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT = 0;
8376
8377	//=== VK_KHR_maintenance4 ===
8378	PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR = 0;
8379	PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR = 0;
8380	PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR = 0;
8381
8382	//=== VK_VALVE_descriptor_set_host_mapping ===
8383	PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE = 0;
8384	PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE = 0;
8385
8386	//=== VK_NV_copy_memory_indirect ===
8387	PFN_vkCmdCopyMemoryIndirectNV vkCmdCopyMemoryIndirectNV = 0;
8388	PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV = 0;
8389
8390	//=== VK_NV_memory_decompression ===
8391	PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV = 0;
8392	PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV = 0;
8393
8394	//=== VK_EXT_extended_dynamic_state3 ===
8395	PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT = 0;
8396	PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT = 0;
8397	PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT = 0;
8398	PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT = 0;
8399	PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT = 0;
8400	PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT = 0;
8401	PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT = 0;
8402	PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT = 0;
8403	PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT = 0;
8404	PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT = 0;
8405	PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT = 0;
8406	PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT = 0;
8407	PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT = 0;
8408	PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT = 0;
8409	PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT = 0;
8410	PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT = 0;
8411	PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT = 0;
8412	PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT = 0;
8413	PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT = 0;
8414	PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT = 0;
8415	PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT = 0;
8416	PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV = 0;
8417	PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV = 0;
8418	PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV = 0;
8419	PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV = 0;
8420	PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV = 0;
8421	PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV = 0;
8422	PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV = 0;
8423	PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV = 0;
8424	PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV = 0;
8425	PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV = 0;
8426
8427	//=== VK_EXT_shader_module_identifier ===
8428	PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT = 0;
8429	PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT = 0;
8430
8431	//=== VK_NV_optical_flow ===
8432	PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV vkGetPhysicalDeviceOpticalFlowImageFormatsNV = 0;
8433	PFN_vkCreateOpticalFlowSessionNV vkCreateOpticalFlowSessionNV = 0;
8434	PFN_vkDestroyOpticalFlowSessionNV vkDestroyOpticalFlowSessionNV = 0;
8435	PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV = 0;
8436	PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV = 0;
8437
8438	//=== VK_QCOM_tile_properties ===
8439	PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0;
8440	PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0;
8441
8442
8443	public:
8444	DispatchLoaderDynamic() VULKAN_HPP_NOEXCEPT = default;
8445	DispatchLoaderDynamic( DispatchLoaderDynamic const & rhs ) VULKAN_HPP_NOEXCEPT = default;
8446
8447	DispatchLoaderDynamic(PFN_vkGetInstanceProcAddr getInstanceProcAddr) VULKAN_HPP_NOEXCEPT
8448	{
8449	init(getInstanceProcAddr);
8450	}
8451
8452	void init( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) VULKAN_HPP_NOEXCEPT
8453	{
8454	VULKAN_HPP_ASSERT(getInstanceProcAddr);
8455
8456	vkGetInstanceProcAddr = getInstanceProcAddr;
8457
8458
8459	//=== VK_VERSION_1_0 ===
8460	vkCreateInstance = PFN_vkCreateInstance( vkGetInstanceProcAddr( NULL, "vkCreateInstance" ) );
8461	vkEnumerateInstanceExtensionProperties = PFN_vkEnumerateInstanceExtensionProperties( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceExtensionProperties" ) );
8462	vkEnumerateInstanceLayerProperties = PFN_vkEnumerateInstanceLayerProperties( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceLayerProperties" ) );
8463
8464	//=== VK_VERSION_1_1 ===
8465	vkEnumerateInstanceVersion = PFN_vkEnumerateInstanceVersion( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceVersion" ) );
8466
8467	}
8468
8469	// This interface does not require a linked vulkan library.
8470	DispatchLoaderDynamic( VkInstance instance,
8471	PFN_vkGetInstanceProcAddr getInstanceProcAddr,
8472	VkDevice device = {},
8473	PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr ) VULKAN_HPP_NOEXCEPT
8474	{
8475	init( instance, getInstanceProcAddr, device, getDeviceProcAddr );
8476	}
8477
8478	// This interface does not require a linked vulkan library.
8479	void init( VkInstance instance,
8480	PFN_vkGetInstanceProcAddr getInstanceProcAddr,
8481	VkDevice device = {},
8482	PFN_vkGetDeviceProcAddr /*getDeviceProcAddr*/ = nullptr ) VULKAN_HPP_NOEXCEPT
8483	{
8484	VULKAN_HPP_ASSERT(instance && getInstanceProcAddr);
8485	vkGetInstanceProcAddr = getInstanceProcAddr;
8486	init( VULKAN_HPP_NAMESPACE::Instance(instance) );
8487	if (device) {
8488	init( VULKAN_HPP_NAMESPACE::Device(device) );
8489	}
8490	}
8491
8492	void init( VULKAN_HPP_NAMESPACE::Instance instanceCpp ) VULKAN_HPP_NOEXCEPT
8493	{
8494	VkInstance instance = static_cast<VkInstance>(instanceCpp);
8495
8496
8497	//=== VK_VERSION_1_0 ===
8498	vkDestroyInstance = PFN_vkDestroyInstance( vkGetInstanceProcAddr( instance, "vkDestroyInstance" ) );
8499	vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDevices" ) );
8500	vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures" ) );
8501	vkGetPhysicalDeviceFormatProperties = PFN_vkGetPhysicalDeviceFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties" ) );
8502	vkGetPhysicalDeviceImageFormatProperties = PFN_vkGetPhysicalDeviceImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties" ) );
8503	vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties" ) );
8504	vkGetPhysicalDeviceQueueFamilyProperties = PFN_vkGetPhysicalDeviceQueueFamilyProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties" ) );
8505	vkGetPhysicalDeviceMemoryProperties = PFN_vkGetPhysicalDeviceMemoryProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties" ) );
8506	vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr" ) );
8507	vkCreateDevice = PFN_vkCreateDevice( vkGetInstanceProcAddr( instance, "vkCreateDevice" ) );
8508	vkDestroyDevice = PFN_vkDestroyDevice( vkGetInstanceProcAddr( instance, "vkDestroyDevice" ) );
8509	vkEnumerateDeviceExtensionProperties = PFN_vkEnumerateDeviceExtensionProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceExtensionProperties" ) );
8510	vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceLayerProperties" ) );
8511	vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue" ) );
8512	vkQueueSubmit = PFN_vkQueueSubmit( vkGetInstanceProcAddr( instance, "vkQueueSubmit" ) );
8513	vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetInstanceProcAddr( instance, "vkQueueWaitIdle" ) );
8514	vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetInstanceProcAddr( instance, "vkDeviceWaitIdle" ) );
8515	vkAllocateMemory = PFN_vkAllocateMemory( vkGetInstanceProcAddr( instance, "vkAllocateMemory" ) );
8516	vkFreeMemory = PFN_vkFreeMemory( vkGetInstanceProcAddr( instance, "vkFreeMemory" ) );
8517	vkMapMemory = PFN_vkMapMemory( vkGetInstanceProcAddr( instance, "vkMapMemory" ) );
8518	vkUnmapMemory = PFN_vkUnmapMemory( vkGetInstanceProcAddr( instance, "vkUnmapMemory" ) );
8519	vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkFlushMappedMemoryRanges" ) );
8520	vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkInvalidateMappedMemoryRanges" ) );
8521	vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryCommitment" ) );
8522	vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetInstanceProcAddr( instance, "vkBindBufferMemory" ) );
8523	vkBindImageMemory = PFN_vkBindImageMemory( vkGetInstanceProcAddr( instance, "vkBindImageMemory" ) );
8524	vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements" ) );
8525	vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements" ) );
8526	vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements" ) );
8527	vkGetPhysicalDeviceSparseImageFormatProperties = PFN_vkGetPhysicalDeviceSparseImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties" ) );
8528	vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetInstanceProcAddr( instance, "vkQueueBindSparse" ) );
8529	vkCreateFence = PFN_vkCreateFence( vkGetInstanceProcAddr( instance, "vkCreateFence" ) );
8530	vkDestroyFence = PFN_vkDestroyFence( vkGetInstanceProcAddr( instance, "vkDestroyFence" ) );
8531	vkResetFences = PFN_vkResetFences( vkGetInstanceProcAddr( instance, "vkResetFences" ) );
8532	vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetInstanceProcAddr( instance, "vkGetFenceStatus" ) );
8533	vkWaitForFences = PFN_vkWaitForFences( vkGetInstanceProcAddr( instance, "vkWaitForFences" ) );
8534	vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetInstanceProcAddr( instance, "vkCreateSemaphore" ) );
8535	vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetInstanceProcAddr( instance, "vkDestroySemaphore" ) );
8536	vkCreateEvent = PFN_vkCreateEvent( vkGetInstanceProcAddr( instance, "vkCreateEvent" ) );
8537	vkDestroyEvent = PFN_vkDestroyEvent( vkGetInstanceProcAddr( instance, "vkDestroyEvent" ) );
8538	vkGetEventStatus = PFN_vkGetEventStatus( vkGetInstanceProcAddr( instance, "vkGetEventStatus" ) );
8539	vkSetEvent = PFN_vkSetEvent( vkGetInstanceProcAddr( instance, "vkSetEvent" ) );
8540	vkResetEvent = PFN_vkResetEvent( vkGetInstanceProcAddr( instance, "vkResetEvent" ) );
8541	vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetInstanceProcAddr( instance, "vkCreateQueryPool" ) );
8542	vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetInstanceProcAddr( instance, "vkDestroyQueryPool" ) );
8543	vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetInstanceProcAddr( instance, "vkGetQueryPoolResults" ) );
8544	vkCreateBuffer = PFN_vkCreateBuffer( vkGetInstanceProcAddr( instance, "vkCreateBuffer" ) );
8545	vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetInstanceProcAddr( instance, "vkDestroyBuffer" ) );
8546	vkCreateBufferView = PFN_vkCreateBufferView( vkGetInstanceProcAddr( instance, "vkCreateBufferView" ) );
8547	vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetInstanceProcAddr( instance, "vkDestroyBufferView" ) );
8548	vkCreateImage = PFN_vkCreateImage( vkGetInstanceProcAddr( instance, "vkCreateImage" ) );
8549	vkDestroyImage = PFN_vkDestroyImage( vkGetInstanceProcAddr( instance, "vkDestroyImage" ) );
8550	vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout" ) );
8551	vkCreateImageView = PFN_vkCreateImageView( vkGetInstanceProcAddr( instance, "vkCreateImageView" ) );
8552	vkDestroyImageView = PFN_vkDestroyImageView( vkGetInstanceProcAddr( instance, "vkDestroyImageView" ) );
8553	vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetInstanceProcAddr( instance, "vkCreateShaderModule" ) );
8554	vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetInstanceProcAddr( instance, "vkDestroyShaderModule" ) );
8555	vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetInstanceProcAddr( instance, "vkCreatePipelineCache" ) );
8556	vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetInstanceProcAddr( instance, "vkDestroyPipelineCache" ) );
8557	vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetInstanceProcAddr( instance, "vkGetPipelineCacheData" ) );
8558	vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetInstanceProcAddr( instance, "vkMergePipelineCaches" ) );
8559	vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetInstanceProcAddr( instance, "vkCreateGraphicsPipelines" ) );
8560	vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetInstanceProcAddr( instance, "vkCreateComputePipelines" ) );
8561	vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetInstanceProcAddr( instance, "vkDestroyPipeline" ) );
8562	vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetInstanceProcAddr( instance, "vkCreatePipelineLayout" ) );
8563	vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetInstanceProcAddr( instance, "vkDestroyPipelineLayout" ) );
8564	vkCreateSampler = PFN_vkCreateSampler( vkGetInstanceProcAddr( instance, "vkCreateSampler" ) );
8565	vkDestroySampler = PFN_vkDestroySampler( vkGetInstanceProcAddr( instance, "vkDestroySampler" ) );
8566	vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkCreateDescriptorSetLayout" ) );
8567	vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorSetLayout" ) );
8568	vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetInstanceProcAddr( instance, "vkCreateDescriptorPool" ) );
8569	vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorPool" ) );
8570	vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetInstanceProcAddr( instance, "vkResetDescriptorPool" ) );
8571	vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetInstanceProcAddr( instance, "vkAllocateDescriptorSets" ) );
8572	vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetInstanceProcAddr( instance, "vkFreeDescriptorSets" ) );
8573	vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSets" ) );
8574	vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetInstanceProcAddr( instance, "vkCreateFramebuffer" ) );
8575	vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetInstanceProcAddr( instance, "vkDestroyFramebuffer" ) );
8576	vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetInstanceProcAddr( instance, "vkCreateRenderPass" ) );
8577	vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetInstanceProcAddr( instance, "vkDestroyRenderPass" ) );
8578	vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetInstanceProcAddr( instance, "vkGetRenderAreaGranularity" ) );
8579	vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetInstanceProcAddr( instance, "vkCreateCommandPool" ) );
8580	vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetInstanceProcAddr( instance, "vkDestroyCommandPool" ) );
8581	vkResetCommandPool = PFN_vkResetCommandPool( vkGetInstanceProcAddr( instance, "vkResetCommandPool" ) );
8582	vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetInstanceProcAddr( instance, "vkAllocateCommandBuffers" ) );
8583	vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetInstanceProcAddr( instance, "vkFreeCommandBuffers" ) );
8584	vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetInstanceProcAddr( instance, "vkBeginCommandBuffer" ) );
8585	vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetInstanceProcAddr( instance, "vkEndCommandBuffer" ) );
8586	vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetInstanceProcAddr( instance, "vkResetCommandBuffer" ) );
8587	vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetInstanceProcAddr( instance, "vkCmdBindPipeline" ) );
8588	vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetInstanceProcAddr( instance, "vkCmdSetViewport" ) );
8589	vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetInstanceProcAddr( instance, "vkCmdSetScissor" ) );
8590	vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) );
8591	vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBias" ) );
8592	vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetInstanceProcAddr( instance, "vkCmdSetBlendConstants" ) );
8593	vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBounds" ) );
8594	vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilCompareMask" ) );
8595	vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilWriteMask" ) );
8596	vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetInstanceProcAddr( instance, "vkCmdSetStencilReference" ) );
8597	vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorSets" ) );
8598	vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer" ) );
8599	vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers" ) );
8600	vkCmdDraw = PFN_vkCmdDraw( vkGetInstanceProcAddr( instance, "vkCmdDraw" ) );
8601	vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexed" ) );
8602	vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirect" ) );
8603	vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirect" ) );
8604	vkCmdDispatch = PFN_vkCmdDispatch( vkGetInstanceProcAddr( instance, "vkCmdDispatch" ) );
8605	vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetInstanceProcAddr( instance, "vkCmdDispatchIndirect" ) );
8606	vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer" ) );
8607	vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetInstanceProcAddr( instance, "vkCmdCopyImage" ) );
8608	vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetInstanceProcAddr( instance, "vkCmdBlitImage" ) );
8609	vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage" ) );
8610	vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer" ) );
8611	vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetInstanceProcAddr( instance, "vkCmdUpdateBuffer" ) );
8612	vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetInstanceProcAddr( instance, "vkCmdFillBuffer" ) );
8613	vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetInstanceProcAddr( instance, "vkCmdClearColorImage" ) );
8614	vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetInstanceProcAddr( instance, "vkCmdClearDepthStencilImage" ) );
8615	vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetInstanceProcAddr( instance, "vkCmdClearAttachments" ) );
8616	vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetInstanceProcAddr( instance, "vkCmdResolveImage" ) );
8617	vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetInstanceProcAddr( instance, "vkCmdSetEvent" ) );
8618	vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetInstanceProcAddr( instance, "vkCmdResetEvent" ) );
8619	vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents" ) );
8620	vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier" ) );
8621	vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetInstanceProcAddr( instance, "vkCmdBeginQuery" ) );
8622	vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetInstanceProcAddr( instance, "vkCmdEndQuery" ) );
8623	vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetInstanceProcAddr( instance, "vkCmdResetQueryPool" ) );
8624	vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp" ) );
8625	vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetInstanceProcAddr( instance, "vkCmdCopyQueryPoolResults" ) );
8626	vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetInstanceProcAddr( instance, "vkCmdPushConstants" ) );
8627	vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass" ) );
8628	vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass" ) );
8629	vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass" ) );
8630	vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetInstanceProcAddr( instance, "vkCmdExecuteCommands" ) );
8631
8632	//=== VK_VERSION_1_1 ===
8633	vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2" ) );
8634	vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetInstanceProcAddr( instance, "vkBindImageMemory2" ) );
8635	vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeatures" ) );
8636	vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMask" ) );
8637	vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetInstanceProcAddr( instance, "vkCmdDispatchBase" ) );
8638	vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroups" ) );
8639	vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2" ) );
8640	vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2" ) );
8641	vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2" ) );
8642	vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2" ) );
8643	vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) );
8644	vkGetPhysicalDeviceFormatProperties2 = PFN_vkGetPhysicalDeviceFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2" ) );
8645	vkGetPhysicalDeviceImageFormatProperties2 = PFN_vkGetPhysicalDeviceImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2" ) );
8646	vkGetPhysicalDeviceQueueFamilyProperties2 = PFN_vkGetPhysicalDeviceQueueFamilyProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) );
8647	vkGetPhysicalDeviceMemoryProperties2 = PFN_vkGetPhysicalDeviceMemoryProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2" ) );
8648	vkGetPhysicalDeviceSparseImageFormatProperties2 = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2" ) );
8649	vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetInstanceProcAddr( instance, "vkTrimCommandPool" ) );
8650	vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue2" ) );
8651	vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversion" ) );
8652	vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversion" ) );
8653	vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplate" ) );
8654	vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplate" ) );
8655	vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplate" ) );
8656	vkGetPhysicalDeviceExternalBufferProperties = PFN_vkGetPhysicalDeviceExternalBufferProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferProperties" ) );
8657	vkGetPhysicalDeviceExternalFenceProperties = PFN_vkGetPhysicalDeviceExternalFenceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFenceProperties" ) );
8658	vkGetPhysicalDeviceExternalSemaphoreProperties = PFN_vkGetPhysicalDeviceExternalSemaphoreProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphoreProperties" ) );
8659	vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupport" ) );
8660
8661	//=== VK_VERSION_1_2 ===
8662	vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCount" ) );
8663	vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCount" ) );
8664	vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2" ) );
8665	vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2" ) );
8666	vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2" ) );
8667	vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2" ) );
8668	vkResetQueryPool = PFN_vkResetQueryPool( vkGetInstanceProcAddr( instance, "vkResetQueryPool" ) );
8669	vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValue" ) );
8670	vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetInstanceProcAddr( instance, "vkWaitSemaphores" ) );
8671	vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetInstanceProcAddr( instance, "vkSignalSemaphore" ) );
8672	vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddress" ) );
8673	vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureAddress" ) );
8674	vkGetDeviceMemoryOpaqueCaptureAddress = PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryOpaqueCaptureAddress" ) );
8675
8676	//=== VK_VERSION_1_3 ===
8677	vkGetPhysicalDeviceToolProperties = PFN_vkGetPhysicalDeviceToolProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolProperties" ) );
8678	vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetInstanceProcAddr( instance, "vkCreatePrivateDataSlot" ) );
8679	vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetInstanceProcAddr( instance, "vkDestroyPrivateDataSlot" ) );
8680	vkSetPrivateData = PFN_vkSetPrivateData( vkGetInstanceProcAddr( instance, "vkSetPrivateData" ) );
8681	vkGetPrivateData = PFN_vkGetPrivateData( vkGetInstanceProcAddr( instance, "vkGetPrivateData" ) );
8682	vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetInstanceProcAddr( instance, "vkCmdSetEvent2" ) );
8683	vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetInstanceProcAddr( instance, "vkCmdResetEvent2" ) );
8684	vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents2" ) );
8685	vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier2" ) );
8686	vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp2" ) );
8687	vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetInstanceProcAddr( instance, "vkQueueSubmit2" ) );
8688	vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer2" ) );
8689	vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetInstanceProcAddr( instance, "vkCmdCopyImage2" ) );
8690	vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage2" ) );
8691	vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer2" ) );
8692	vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetInstanceProcAddr( instance, "vkCmdBlitImage2" ) );
8693	vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetInstanceProcAddr( instance, "vkCmdResolveImage2" ) );
8694	vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetInstanceProcAddr( instance, "vkCmdBeginRendering" ) );
8695	vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetInstanceProcAddr( instance, "vkCmdEndRendering" ) );
8696	vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetInstanceProcAddr( instance, "vkCmdSetCullMode" ) );
8697	vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetInstanceProcAddr( instance, "vkCmdSetFrontFace" ) );
8698	vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveTopology" ) );
8699	vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWithCount" ) );
8700	vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetInstanceProcAddr( instance, "vkCmdSetScissorWithCount" ) );
8701	vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers2" ) );
8702	vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthTestEnable" ) );
8703	vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthWriteEnable" ) );
8704	vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetInstanceProcAddr( instance, "vkCmdSetDepthCompareOp" ) );
8705	vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBoundsTestEnable" ) );
8706	vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetStencilTestEnable" ) );
8707	vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetInstanceProcAddr( instance, "vkCmdSetStencilOp" ) );
8708	vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizerDiscardEnable" ) );
8709	vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBiasEnable" ) );
8710	vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveRestartEnable" ) );
8711	vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceBufferMemoryRequirements" ) );
8712	vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceImageMemoryRequirements" ) );
8713	vkGetDeviceImageSparseMemoryRequirements = PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSparseMemoryRequirements" ) );
8714
8715	//=== VK_KHR_surface ===
8716	vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR( vkGetInstanceProcAddr( instance, "vkDestroySurfaceKHR" ) );
8717	vkGetPhysicalDeviceSurfaceSupportKHR = PFN_vkGetPhysicalDeviceSurfaceSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceSupportKHR" ) );
8718	vkGetPhysicalDeviceSurfaceCapabilitiesKHR = PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR" ) );
8719	vkGetPhysicalDeviceSurfaceFormatsKHR = PFN_vkGetPhysicalDeviceSurfaceFormatsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormatsKHR" ) );
8720	vkGetPhysicalDeviceSurfacePresentModesKHR = PFN_vkGetPhysicalDeviceSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModesKHR" ) );
8721
8722	//=== VK_KHR_swapchain ===
8723	vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetInstanceProcAddr( instance, "vkCreateSwapchainKHR" ) );
8724	vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetInstanceProcAddr( instance, "vkDestroySwapchainKHR" ) );
8725	vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetInstanceProcAddr( instance, "vkGetSwapchainImagesKHR" ) );
8726	vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImageKHR" ) );
8727	vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetInstanceProcAddr( instance, "vkQueuePresentKHR" ) );
8728	vkGetDeviceGroupPresentCapabilitiesKHR = PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPresentCapabilitiesKHR" ) );
8729	vkGetDeviceGroupSurfacePresentModesKHR = PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModesKHR" ) );
8730	vkGetPhysicalDevicePresentRectanglesKHR = PFN_vkGetPhysicalDevicePresentRectanglesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDevicePresentRectanglesKHR" ) );
8731	vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImage2KHR" ) );
8732
8733	//=== VK_KHR_display ===
8734	vkGetPhysicalDeviceDisplayPropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPropertiesKHR" ) );
8735	vkGetPhysicalDeviceDisplayPlanePropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR" ) );
8736	vkGetDisplayPlaneSupportedDisplaysKHR = PFN_vkGetDisplayPlaneSupportedDisplaysKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneSupportedDisplaysKHR" ) );
8737	vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModePropertiesKHR" ) );
8738	vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) );
8739	vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilitiesKHR" ) );
8740	vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayPlaneSurfaceKHR" ) );
8741
8742	//=== VK_KHR_display_swapchain ===
8743	vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetInstanceProcAddr( instance, "vkCreateSharedSwapchainsKHR" ) );
8744
8745	#if defined( VK_USE_PLATFORM_XLIB_KHR )
8746	//=== VK_KHR_xlib_surface ===
8747	vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXlibSurfaceKHR" ) );
8748	vkGetPhysicalDeviceXlibPresentationSupportKHR = PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR" ) );
8749	#endif /*VK_USE_PLATFORM_XLIB_KHR*/
8750
8751	#if defined( VK_USE_PLATFORM_XCB_KHR )
8752	//=== VK_KHR_xcb_surface ===
8753	vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXcbSurfaceKHR" ) );
8754	vkGetPhysicalDeviceXcbPresentationSupportKHR = PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR" ) );
8755	#endif /*VK_USE_PLATFORM_XCB_KHR*/
8756
8757	#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
8758	//=== VK_KHR_wayland_surface ===
8759	vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWaylandSurfaceKHR" ) );
8760	vkGetPhysicalDeviceWaylandPresentationSupportKHR = PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR" ) );
8761	#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
8762
8763	#if defined( VK_USE_PLATFORM_ANDROID_KHR )
8764	//=== VK_KHR_android_surface ===
8765	vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) );
8766	#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
8767
8768	#if defined( VK_USE_PLATFORM_WIN32_KHR )
8769	//=== VK_KHR_win32_surface ===
8770	vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWin32SurfaceKHR" ) );
8771	vkGetPhysicalDeviceWin32PresentationSupportKHR = PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR" ) );
8772	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
8773
8774	//=== VK_EXT_debug_report ===
8775	vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugReportCallbackEXT" ) );
8776	vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugReportCallbackEXT" ) );
8777	vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT( vkGetInstanceProcAddr( instance, "vkDebugReportMessageEXT" ) );
8778
8779	//=== VK_EXT_debug_marker ===
8780	vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectTagEXT" ) );
8781	vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectNameEXT" ) );
8782	vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerBeginEXT" ) );
8783	vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerEndEXT" ) );
8784	vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerInsertEXT" ) );
8785
8786	//=== VK_KHR_video_queue ===
8787	vkGetPhysicalDeviceVideoCapabilitiesKHR = PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR" ) );
8788	vkGetPhysicalDeviceVideoFormatPropertiesKHR = PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR" ) );
8789	vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR( vkGetInstanceProcAddr( instance, "vkCreateVideoSessionKHR" ) );
8790	vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR( vkGetInstanceProcAddr( instance, "vkDestroyVideoSessionKHR" ) );
8791	vkGetVideoSessionMemoryRequirementsKHR = PFN_vkGetVideoSessionMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetVideoSessionMemoryRequirementsKHR" ) );
8792	vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR( vkGetInstanceProcAddr( instance, "vkBindVideoSessionMemoryKHR" ) );
8793	vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkCreateVideoSessionParametersKHR" ) );
8794	vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkUpdateVideoSessionParametersKHR" ) );
8795	vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkDestroyVideoSessionParametersKHR" ) );
8796	vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdBeginVideoCodingKHR" ) );
8797	vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdEndVideoCodingKHR" ) );
8798	vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdControlVideoCodingKHR" ) );
8799
8800	//=== VK_KHR_video_decode_queue ===
8801	vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetInstanceProcAddr( instance, "vkCmdDecodeVideoKHR" ) );
8802
8803	//=== VK_EXT_transform_feedback ===
8804	vkCmdBindTransformFeedbackBuffersEXT = PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindTransformFeedbackBuffersEXT" ) );
8805	vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginTransformFeedbackEXT" ) );
8806	vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetInstanceProcAddr( instance, "vkCmdEndTransformFeedbackEXT" ) );
8807	vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginQueryIndexedEXT" ) );
8808	vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdEndQueryIndexedEXT" ) );
8809	vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectByteCountEXT" ) );
8810
8811	//=== VK_NVX_binary_import ===
8812	vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetInstanceProcAddr( instance, "vkCreateCuModuleNVX" ) );
8813	vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetInstanceProcAddr( instance, "vkCreateCuFunctionNVX" ) );
8814	vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetInstanceProcAddr( instance, "vkDestroyCuModuleNVX" ) );
8815	vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetInstanceProcAddr( instance, "vkDestroyCuFunctionNVX" ) );
8816	vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetInstanceProcAddr( instance, "vkCmdCuLaunchKernelNVX" ) );
8817
8818	//=== VK_NVX_image_view_handle ===
8819	vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewHandleNVX" ) );
8820	vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewAddressNVX" ) );
8821
8822	//=== VK_AMD_draw_indirect_count ===
8823	vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountAMD" ) );
8824	if ( !vkCmdDrawIndirectCount ) vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD;
8825	vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountAMD" ) );
8826	if ( !vkCmdDrawIndexedIndirectCount ) vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD;
8827
8828	//=== VK_AMD_shader_info ===
8829	vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetInstanceProcAddr( instance, "vkGetShaderInfoAMD" ) );
8830
8831	//=== VK_KHR_dynamic_rendering ===
8832	vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderingKHR" ) );
8833	if ( !vkCmdBeginRendering ) vkCmdBeginRendering = vkCmdBeginRenderingKHR;
8834	vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetInstanceProcAddr( instance, "vkCmdEndRenderingKHR" ) );
8835	if ( !vkCmdEndRendering ) vkCmdEndRendering = vkCmdEndRenderingKHR;
8836
8837	#if defined( VK_USE_PLATFORM_GGP )
8838	//=== VK_GGP_stream_descriptor_surface ===
8839	vkCreateStreamDescriptorSurfaceGGP = PFN_vkCreateStreamDescriptorSurfaceGGP( vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ) );
8840	#endif /*VK_USE_PLATFORM_GGP*/
8841
8842	//=== VK_NV_external_memory_capabilities ===
8843	vkGetPhysicalDeviceExternalImageFormatPropertiesNV = PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV" ) );
8844
8845	#if defined( VK_USE_PLATFORM_WIN32_KHR )
8846	//=== VK_NV_external_memory_win32 ===
8847	vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleNV" ) );
8848	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
8849
8850	//=== VK_KHR_get_physical_device_properties2 ===
8851	vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2KHR" ) );
8852	if ( !vkGetPhysicalDeviceFeatures2 ) vkGetPhysicalDeviceFeatures2 = vkGetPhysicalDeviceFeatures2KHR;
8853	vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2KHR" ) );
8854	if ( !vkGetPhysicalDeviceProperties2 ) vkGetPhysicalDeviceProperties2 = vkGetPhysicalDeviceProperties2KHR;
8855	vkGetPhysicalDeviceFormatProperties2KHR = PFN_vkGetPhysicalDeviceFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2KHR" ) );
8856	if ( !vkGetPhysicalDeviceFormatProperties2 ) vkGetPhysicalDeviceFormatProperties2 = vkGetPhysicalDeviceFormatProperties2KHR;
8857	vkGetPhysicalDeviceImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2KHR" ) );
8858	if ( !vkGetPhysicalDeviceImageFormatProperties2 ) vkGetPhysicalDeviceImageFormatProperties2 = vkGetPhysicalDeviceImageFormatProperties2KHR;
8859	vkGetPhysicalDeviceQueueFamilyProperties2KHR = PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR" ) );
8860	if ( !vkGetPhysicalDeviceQueueFamilyProperties2 ) vkGetPhysicalDeviceQueueFamilyProperties2 = vkGetPhysicalDeviceQueueFamilyProperties2KHR;
8861	vkGetPhysicalDeviceMemoryProperties2KHR = PFN_vkGetPhysicalDeviceMemoryProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2KHR" ) );
8862	if ( !vkGetPhysicalDeviceMemoryProperties2 ) vkGetPhysicalDeviceMemoryProperties2 = vkGetPhysicalDeviceMemoryProperties2KHR;
8863	vkGetPhysicalDeviceSparseImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR" ) );
8864	if ( !vkGetPhysicalDeviceSparseImageFormatProperties2 ) vkGetPhysicalDeviceSparseImageFormatProperties2 = vkGetPhysicalDeviceSparseImageFormatProperties2KHR;
8865
8866	//=== VK_KHR_device_group ===
8867	vkGetDeviceGroupPeerMemoryFeaturesKHR = PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) );
8868	if ( !vkGetDeviceGroupPeerMemoryFeatures ) vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR;
8869	vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMaskKHR" ) );
8870	if ( !vkCmdSetDeviceMask ) vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR;
8871	vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetInstanceProcAddr( instance, "vkCmdDispatchBaseKHR" ) );
8872	if ( !vkCmdDispatchBase ) vkCmdDispatchBase = vkCmdDispatchBaseKHR;
8873
8874	#if defined( VK_USE_PLATFORM_VI_NN )
8875	//=== VK_NN_vi_surface ===
8876	vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN( vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ) );
8877	#endif /*VK_USE_PLATFORM_VI_NN*/
8878
8879	//=== VK_KHR_maintenance1 ===
8880	vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetInstanceProcAddr( instance, "vkTrimCommandPoolKHR" ) );
8881	if ( !vkTrimCommandPool ) vkTrimCommandPool = vkTrimCommandPoolKHR;
8882
8883	//=== VK_KHR_device_group_creation ===
8884	vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroupsKHR" ) );
8885	if ( !vkEnumeratePhysicalDeviceGroups ) vkEnumeratePhysicalDeviceGroups = vkEnumeratePhysicalDeviceGroupsKHR;
8886
8887	//=== VK_KHR_external_memory_capabilities ===
8888	vkGetPhysicalDeviceExternalBufferPropertiesKHR = PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR" ) );
8889	if ( !vkGetPhysicalDeviceExternalBufferProperties ) vkGetPhysicalDeviceExternalBufferProperties = vkGetPhysicalDeviceExternalBufferPropertiesKHR;
8890
8891	#if defined( VK_USE_PLATFORM_WIN32_KHR )
8892	//=== VK_KHR_external_memory_win32 ===
8893	vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleKHR" ) );
8894	vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandlePropertiesKHR" ) );
8895	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
8896
8897	//=== VK_KHR_external_memory_fd ===
8898	vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryFdKHR" ) );
8899	vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryFdPropertiesKHR" ) );
8900
8901	//=== VK_KHR_external_semaphore_capabilities ===
8902	vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR" ) );
8903	if ( !vkGetPhysicalDeviceExternalSemaphoreProperties ) vkGetPhysicalDeviceExternalSemaphoreProperties = vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
8904
8905	#if defined( VK_USE_PLATFORM_WIN32_KHR )
8906	//=== VK_KHR_external_semaphore_win32 ===
8907	vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkImportSemaphoreWin32HandleKHR" ) );
8908	vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreWin32HandleKHR" ) );
8909	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
8910
8911	//=== VK_KHR_external_semaphore_fd ===
8912	vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkImportSemaphoreFdKHR" ) );
8913	vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreFdKHR" ) );
8914
8915	//=== VK_KHR_push_descriptor ===
8916	vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetKHR" ) );
8917	vkCmdPushDescriptorSetWithTemplateKHR = PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplateKHR" ) );
8918
8919	//=== VK_EXT_conditional_rendering ===
8920	vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginConditionalRenderingEXT" ) );
8921	vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetInstanceProcAddr( instance, "vkCmdEndConditionalRenderingEXT" ) );
8922
8923	//=== VK_KHR_descriptor_update_template ===
8924	vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplateKHR" ) );
8925	if ( !vkCreateDescriptorUpdateTemplate ) vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR;
8926	vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplateKHR" ) );
8927	if ( !vkDestroyDescriptorUpdateTemplate ) vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR;
8928	vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplateKHR" ) );
8929	if ( !vkUpdateDescriptorSetWithTemplate ) vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR;
8930
8931	//=== VK_NV_clip_space_w_scaling ===
8932	vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWScalingNV" ) );
8933
8934	//=== VK_EXT_direct_mode_display ===
8935	vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) );
8936
8937	#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
8938	//=== VK_EXT_acquire_xlib_display ===
8939	vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) );
8940	vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) );
8941	#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
8942
8943	//=== VK_EXT_display_surface_counter ===
8944	vkGetPhysicalDeviceSurfaceCapabilities2EXT = PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT" ) );
8945
8946	//=== VK_EXT_display_control ===
8947	vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetInstanceProcAddr( instance, "vkDisplayPowerControlEXT" ) );
8948	vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDeviceEventEXT" ) );
8949	vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDisplayEventEXT" ) );
8950	vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetInstanceProcAddr( instance, "vkGetSwapchainCounterEXT" ) );
8951
8952	//=== VK_GOOGLE_display_timing ===
8953	vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetInstanceProcAddr( instance, "vkGetRefreshCycleDurationGOOGLE" ) );
8954	vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetInstanceProcAddr( instance, "vkGetPastPresentationTimingGOOGLE" ) );
8955
8956	//=== VK_EXT_discard_rectangles ===
8957	vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEXT" ) );
8958
8959	//=== VK_EXT_hdr_metadata ===
8960	vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetInstanceProcAddr( instance, "vkSetHdrMetadataEXT" ) );
8961
8962	//=== VK_KHR_create_renderpass2 ===
8963	vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2KHR" ) );
8964	if ( !vkCreateRenderPass2 ) vkCreateRenderPass2 = vkCreateRenderPass2KHR;
8965	vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2KHR" ) );
8966	if ( !vkCmdBeginRenderPass2 ) vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR;
8967	vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2KHR" ) );
8968	if ( !vkCmdNextSubpass2 ) vkCmdNextSubpass2 = vkCmdNextSubpass2KHR;
8969	vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2KHR" ) );
8970	if ( !vkCmdEndRenderPass2 ) vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR;
8971
8972	//=== VK_KHR_shared_presentable_image ===
8973	vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetInstanceProcAddr( instance, "vkGetSwapchainStatusKHR" ) );
8974
8975	//=== VK_KHR_external_fence_capabilities ===
8976	vkGetPhysicalDeviceExternalFencePropertiesKHR = PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR" ) );
8977	if ( !vkGetPhysicalDeviceExternalFenceProperties ) vkGetPhysicalDeviceExternalFenceProperties = vkGetPhysicalDeviceExternalFencePropertiesKHR;
8978
8979	#if defined( VK_USE_PLATFORM_WIN32_KHR )
8980	//=== VK_KHR_external_fence_win32 ===
8981	vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkImportFenceWin32HandleKHR" ) );
8982	vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetFenceWin32HandleKHR" ) );
8983	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
8984
8985	//=== VK_KHR_external_fence_fd ===
8986	vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetInstanceProcAddr( instance, "vkImportFenceFdKHR" ) );
8987	vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetInstanceProcAddr( instance, "vkGetFenceFdKHR" ) );
8988
8989	//=== VK_KHR_performance_query ===
8990	vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR" ) );
8991	vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" ) );
8992	vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkAcquireProfilingLockKHR" ) );
8993	vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkReleaseProfilingLockKHR" ) );
8994
8995	//=== VK_KHR_get_surface_capabilities2 ===
8996	vkGetPhysicalDeviceSurfaceCapabilities2KHR = PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR" ) );
8997	vkGetPhysicalDeviceSurfaceFormats2KHR = PFN_vkGetPhysicalDeviceSurfaceFormats2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormats2KHR" ) );
8998
8999	//=== VK_KHR_get_display_properties2 ===
9000	vkGetPhysicalDeviceDisplayProperties2KHR = PFN_vkGetPhysicalDeviceDisplayProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayProperties2KHR" ) );
9001	vkGetPhysicalDeviceDisplayPlaneProperties2KHR = PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR" ) );
9002	vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModeProperties2KHR" ) );
9003	vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilities2KHR" ) );
9004
9005	#if defined( VK_USE_PLATFORM_IOS_MVK )
9006	//=== VK_MVK_ios_surface ===
9007	vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ) );
9008	#endif /*VK_USE_PLATFORM_IOS_MVK*/
9009
9010	#if defined( VK_USE_PLATFORM_MACOS_MVK )
9011	//=== VK_MVK_macos_surface ===
9012	vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateMacOSSurfaceMVK" ) );
9013	#endif /*VK_USE_PLATFORM_MACOS_MVK*/
9014
9015	//=== VK_EXT_debug_utils ===
9016	vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectNameEXT" ) );
9017	vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectTagEXT" ) );
9018	vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueBeginDebugUtilsLabelEXT" ) );
9019	vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueEndDebugUtilsLabelEXT" ) );
9020	vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueInsertDebugUtilsLabelEXT" ) );
9021	vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginDebugUtilsLabelEXT" ) );
9022	vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdEndDebugUtilsLabelEXT" ) );
9023	vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdInsertDebugUtilsLabelEXT" ) );
9024	vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugUtilsMessengerEXT" ) );
9025	vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugUtilsMessengerEXT" ) );
9026	vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) );
9027
9028	#if defined( VK_USE_PLATFORM_ANDROID_KHR )
9029	//=== VK_ANDROID_external_memory_android_hardware_buffer ===
9030	vkGetAndroidHardwareBufferPropertiesANDROID = PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetInstanceProcAddr( instance, "vkGetAndroidHardwareBufferPropertiesANDROID" ) );
9031	vkGetMemoryAndroidHardwareBufferANDROID = PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetInstanceProcAddr( instance, "vkGetMemoryAndroidHardwareBufferANDROID" ) );
9032	#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
9033
9034	//=== VK_EXT_sample_locations ===
9035	vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEXT" ) );
9036	vkGetPhysicalDeviceMultisamplePropertiesEXT = PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT" ) );
9037
9038	//=== VK_KHR_get_memory_requirements2 ===
9039	vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2KHR" ) );
9040	if ( !vkGetImageMemoryRequirements2 ) vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR;
9041	vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2KHR" ) );
9042	if ( !vkGetBufferMemoryRequirements2 ) vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR;
9043	vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2KHR" ) );
9044	if ( !vkGetImageSparseMemoryRequirements2 ) vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR;
9045
9046	//=== VK_KHR_acceleration_structure ===
9047	vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCreateAccelerationStructureKHR" ) );
9048	vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureKHR" ) );
9049	vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructuresKHR" ) );
9050	vkCmdBuildAccelerationStructuresIndirectKHR = PFN_vkCmdBuildAccelerationStructuresIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructuresIndirectKHR" ) );
9051	vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR( vkGetInstanceProcAddr( instance, "vkBuildAccelerationStructuresKHR" ) );
9052	vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCopyAccelerationStructureKHR" ) );
9053	vkCopyAccelerationStructureToMemoryKHR = PFN_vkCopyAccelerationStructureToMemoryKHR( vkGetInstanceProcAddr( instance, "vkCopyAccelerationStructureToMemoryKHR" ) );
9054	vkCopyMemoryToAccelerationStructureKHR = PFN_vkCopyMemoryToAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCopyMemoryToAccelerationStructureKHR" ) );
9055	vkWriteAccelerationStructuresPropertiesKHR = PFN_vkWriteAccelerationStructuresPropertiesKHR( vkGetInstanceProcAddr( instance, "vkWriteAccelerationStructuresPropertiesKHR" ) );
9056	vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureKHR" ) );
9057	vkCmdCopyAccelerationStructureToMemoryKHR = PFN_vkCmdCopyAccelerationStructureToMemoryKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureToMemoryKHR" ) );
9058	vkCmdCopyMemoryToAccelerationStructureKHR = PFN_vkCmdCopyMemoryToAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToAccelerationStructureKHR" ) );
9059	vkGetAccelerationStructureDeviceAddressKHR = PFN_vkGetAccelerationStructureDeviceAddressKHR( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureDeviceAddressKHR" ) );
9060	vkCmdWriteAccelerationStructuresPropertiesKHR = PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) );
9061	vkGetDeviceAccelerationStructureCompatibilityKHR = PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) );
9062	vkGetAccelerationStructureBuildSizesKHR = PFN_vkGetAccelerationStructureBuildSizesKHR( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureBuildSizesKHR" ) );
9063
9064	//=== VK_KHR_sampler_ycbcr_conversion ===
9065	vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversionKHR" ) );
9066	if ( !vkCreateSamplerYcbcrConversion ) vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR;
9067	vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversionKHR" ) );
9068	if ( !vkDestroySamplerYcbcrConversion ) vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR;
9069
9070	//=== VK_KHR_bind_memory2 ===
9071	vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2KHR" ) );
9072	if ( !vkBindBufferMemory2 ) vkBindBufferMemory2 = vkBindBufferMemory2KHR;
9073	vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindImageMemory2KHR" ) );
9074	if ( !vkBindImageMemory2 ) vkBindImageMemory2 = vkBindImageMemory2KHR;
9075
9076	//=== VK_EXT_image_drm_format_modifier ===
9077	vkGetImageDrmFormatModifierPropertiesEXT = PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetImageDrmFormatModifierPropertiesEXT" ) );
9078
9079	//=== VK_EXT_validation_cache ===
9080	vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetInstanceProcAddr( instance, "vkCreateValidationCacheEXT" ) );
9081	vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetInstanceProcAddr( instance, "vkDestroyValidationCacheEXT" ) );
9082	vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetInstanceProcAddr( instance, "vkMergeValidationCachesEXT" ) );
9083	vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetInstanceProcAddr( instance, "vkGetValidationCacheDataEXT" ) );
9084
9085	//=== VK_NV_shading_rate_image ===
9086	vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetInstanceProcAddr( instance, "vkCmdBindShadingRateImageNV" ) );
9087	vkCmdSetViewportShadingRatePaletteNV = PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportShadingRatePaletteNV" ) );
9088	vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoarseSampleOrderNV" ) );
9089
9090	//=== VK_NV_ray_tracing ===
9091	vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCreateAccelerationStructureNV" ) );
9092	vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureNV" ) );
9093	vkGetAccelerationStructureMemoryRequirementsNV = PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureMemoryRequirementsNV" ) );
9094	vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( vkGetInstanceProcAddr( instance, "vkBindAccelerationStructureMemoryNV" ) );
9095	vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructureNV" ) );
9096	vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureNV" ) );
9097	vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysNV" ) );
9098	vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetInstanceProcAddr( instance, "vkCreateRayTracingPipelinesNV" ) );
9099	vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesNV" ) );
9100	if ( !vkGetRayTracingShaderGroupHandlesKHR ) vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV;
9101	vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureHandleNV" ) );
9102	vkCmdWriteAccelerationStructuresPropertiesNV = PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesNV" ) );
9103	vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetInstanceProcAddr( instance, "vkCompileDeferredNV" ) );
9104
9105	//=== VK_KHR_maintenance3 ===
9106	vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupportKHR" ) );
9107	if ( !vkGetDescriptorSetLayoutSupport ) vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR;
9108
9109	//=== VK_KHR_draw_indirect_count ===
9110	vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountKHR" ) );
9111	if ( !vkCmdDrawIndirectCount ) vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR;
9112	vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountKHR" ) );
9113	if ( !vkCmdDrawIndexedIndirectCount ) vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR;
9114
9115	//=== VK_EXT_external_memory_host ===
9116	vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryHostPointerPropertiesEXT" ) );
9117
9118	//=== VK_AMD_buffer_marker ===
9119	vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarkerAMD" ) );
9120
9121	//=== VK_EXT_calibrated_timestamps ===
9122	vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) );
9123	vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetInstanceProcAddr( instance, "vkGetCalibratedTimestampsEXT" ) );
9124
9125	//=== VK_NV_mesh_shader ===
9126	vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksNV" ) );
9127	vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectNV" ) );
9128	vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountNV" ) );
9129
9130	//=== VK_NV_scissor_exclusive ===
9131	vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorNV" ) );
9132
9133	//=== VK_NV_device_diagnostic_checkpoints ===
9134	vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetInstanceProcAddr( instance, "vkCmdSetCheckpointNV" ) );
9135	vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointDataNV" ) );
9136
9137	//=== VK_KHR_timeline_semaphore ===
9138	vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValueKHR" ) );
9139	if ( !vkGetSemaphoreCounterValue ) vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR;
9140	vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetInstanceProcAddr( instance, "vkWaitSemaphoresKHR" ) );
9141	if ( !vkWaitSemaphores ) vkWaitSemaphores = vkWaitSemaphoresKHR;
9142	vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetInstanceProcAddr( instance, "vkSignalSemaphoreKHR" ) );
9143	if ( !vkSignalSemaphore ) vkSignalSemaphore = vkSignalSemaphoreKHR;
9144
9145	//=== VK_INTEL_performance_query ===
9146	vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkInitializePerformanceApiINTEL" ) );
9147	vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkUninitializePerformanceApiINTEL" ) );
9148	vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceMarkerINTEL" ) );
9149	vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceStreamMarkerINTEL" ) );
9150	vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceOverrideINTEL" ) );
9151	vkAcquirePerformanceConfigurationINTEL = PFN_vkAcquirePerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkAcquirePerformanceConfigurationINTEL" ) );
9152	vkReleasePerformanceConfigurationINTEL = PFN_vkReleasePerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkReleasePerformanceConfigurationINTEL" ) );
9153	vkQueueSetPerformanceConfigurationINTEL = PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkQueueSetPerformanceConfigurationINTEL" ) );
9154	vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetInstanceProcAddr( instance, "vkGetPerformanceParameterINTEL" ) );
9155
9156	//=== VK_AMD_display_native_hdr ===
9157	vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetInstanceProcAddr( instance, "vkSetLocalDimmingAMD" ) );
9158
9159	#if defined( VK_USE_PLATFORM_FUCHSIA )
9160	//=== VK_FUCHSIA_imagepipe_surface ===
9161	vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateImagePipeSurfaceFUCHSIA" ) );
9162	#endif /*VK_USE_PLATFORM_FUCHSIA*/
9163
9164	#if defined( VK_USE_PLATFORM_METAL_EXT )
9165	//=== VK_EXT_metal_surface ===
9166	vkCreateMetalSurfaceEXT = PFN_vkCreateMetalSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ) );
9167	#endif /*VK_USE_PLATFORM_METAL_EXT*/
9168
9169	//=== VK_KHR_fragment_shading_rate ===
9170	vkGetPhysicalDeviceFragmentShadingRatesKHR = PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR" ) );
9171	vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetInstanceProcAddr( instance, "vkCmdSetFragmentShadingRateKHR" ) );
9172
9173	//=== VK_EXT_buffer_device_address ===
9174	vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressEXT" ) );
9175	if ( !vkGetBufferDeviceAddress ) vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT;
9176
9177	//=== VK_EXT_tooling_info ===
9178	vkGetPhysicalDeviceToolPropertiesEXT = PFN_vkGetPhysicalDeviceToolPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolPropertiesEXT" ) );
9179	if ( !vkGetPhysicalDeviceToolProperties ) vkGetPhysicalDeviceToolProperties = vkGetPhysicalDeviceToolPropertiesEXT;
9180
9181	//=== VK_KHR_present_wait ===
9182	vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetInstanceProcAddr( instance, "vkWaitForPresentKHR" ) );
9183
9184	//=== VK_NV_cooperative_matrix ===
9185	vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV" ) );
9186
9187	//=== VK_NV_coverage_reduction_mode ===
9188	vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" ) );
9189
9190	#if defined( VK_USE_PLATFORM_WIN32_KHR )
9191	//=== VK_EXT_full_screen_exclusive ===
9192	vkGetPhysicalDeviceSurfacePresentModes2EXT = PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT" ) );
9193	vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetInstanceProcAddr( instance, "vkAcquireFullScreenExclusiveModeEXT" ) );
9194	vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetInstanceProcAddr( instance, "vkReleaseFullScreenExclusiveModeEXT" ) );
9195	vkGetDeviceGroupSurfacePresentModes2EXT = PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModes2EXT" ) );
9196	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
9197
9198	//=== VK_EXT_headless_surface ===
9199	vkCreateHeadlessSurfaceEXT = PFN_vkCreateHeadlessSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateHeadlessSurfaceEXT" ) );
9200
9201	//=== VK_KHR_buffer_device_address ===
9202	vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressKHR" ) );
9203	if ( !vkGetBufferDeviceAddress ) vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR;
9204	vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureAddressKHR" ) );
9205	if ( !vkGetBufferOpaqueCaptureAddress ) vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR;
9206	vkGetDeviceMemoryOpaqueCaptureAddressKHR = PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) );
9207	if ( !vkGetDeviceMemoryOpaqueCaptureAddress ) vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR;
9208
9209	//=== VK_EXT_line_rasterization ===
9210	vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEXT" ) );
9211
9212	//=== VK_EXT_host_query_reset ===
9213	vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetInstanceProcAddr( instance, "vkResetQueryPoolEXT" ) );
9214	if ( !vkResetQueryPool ) vkResetQueryPool = vkResetQueryPoolEXT;
9215
9216	//=== VK_EXT_extended_dynamic_state ===
9217	vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetCullModeEXT" ) );
9218	if ( !vkCmdSetCullMode ) vkCmdSetCullMode = vkCmdSetCullModeEXT;
9219	vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetInstanceProcAddr( instance, "vkCmdSetFrontFaceEXT" ) );
9220	if ( !vkCmdSetFrontFace ) vkCmdSetFrontFace = vkCmdSetFrontFaceEXT;
9221	vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveTopologyEXT" ) );
9222	if ( !vkCmdSetPrimitiveTopology ) vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT;
9223	vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWithCountEXT" ) );
9224	if ( !vkCmdSetViewportWithCount ) vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT;
9225	vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetInstanceProcAddr( instance, "vkCmdSetScissorWithCountEXT" ) );
9226	if ( !vkCmdSetScissorWithCount ) vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT;
9227	vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers2EXT" ) );
9228	if ( !vkCmdBindVertexBuffers2 ) vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT;
9229	vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthTestEnableEXT" ) );
9230	if ( !vkCmdSetDepthTestEnable ) vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT;
9231	vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthWriteEnableEXT" ) );
9232	if ( !vkCmdSetDepthWriteEnable ) vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT;
9233	vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthCompareOpEXT" ) );
9234	if ( !vkCmdSetDepthCompareOp ) vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT;
9235	vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBoundsTestEnableEXT" ) );
9236	if ( !vkCmdSetDepthBoundsTestEnable ) vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT;
9237	vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetStencilTestEnableEXT" ) );
9238	if ( !vkCmdSetStencilTestEnable ) vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT;
9239	vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetStencilOpEXT" ) );
9240	if ( !vkCmdSetStencilOp ) vkCmdSetStencilOp = vkCmdSetStencilOpEXT;
9241
9242	//=== VK_KHR_deferred_host_operations ===
9243	vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR( vkGetInstanceProcAddr( instance, "vkCreateDeferredOperationKHR" ) );
9244	vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR( vkGetInstanceProcAddr( instance, "vkDestroyDeferredOperationKHR" ) );
9245	vkGetDeferredOperationMaxConcurrencyKHR = PFN_vkGetDeferredOperationMaxConcurrencyKHR( vkGetInstanceProcAddr( instance, "vkGetDeferredOperationMaxConcurrencyKHR" ) );
9246	vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR( vkGetInstanceProcAddr( instance, "vkGetDeferredOperationResultKHR" ) );
9247	vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR( vkGetInstanceProcAddr( instance, "vkDeferredOperationJoinKHR" ) );
9248
9249	//=== VK_KHR_pipeline_executable_properties ===
9250	vkGetPipelineExecutablePropertiesKHR = PFN_vkGetPipelineExecutablePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutablePropertiesKHR" ) );
9251	vkGetPipelineExecutableStatisticsKHR = PFN_vkGetPipelineExecutableStatisticsKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableStatisticsKHR" ) );
9252	vkGetPipelineExecutableInternalRepresentationsKHR = PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableInternalRepresentationsKHR" ) );
9253
9254	//=== VK_EXT_swapchain_maintenance1 ===
9255	vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesEXT( vkGetInstanceProcAddr( instance, "vkReleaseSwapchainImagesEXT" ) );
9256
9257	//=== VK_NV_device_generated_commands ===
9258	vkGetGeneratedCommandsMemoryRequirementsNV = PFN_vkGetGeneratedCommandsMemoryRequirementsNV( vkGetInstanceProcAddr( instance, "vkGetGeneratedCommandsMemoryRequirementsNV" ) );
9259	vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetInstanceProcAddr( instance, "vkCmdPreprocessGeneratedCommandsNV" ) );
9260	vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV( vkGetInstanceProcAddr( instance, "vkCmdExecuteGeneratedCommandsNV" ) );
9261	vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV( vkGetInstanceProcAddr( instance, "vkCmdBindPipelineShaderGroupNV" ) );
9262	vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV( vkGetInstanceProcAddr( instance, "vkCreateIndirectCommandsLayoutNV" ) );
9263	vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV( vkGetInstanceProcAddr( instance, "vkDestroyIndirectCommandsLayoutNV" ) );
9264
9265	//=== VK_EXT_acquire_drm_display ===
9266	vkAcquireDrmDisplayEXT = PFN_vkAcquireDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireDrmDisplayEXT" ) );
9267	vkGetDrmDisplayEXT = PFN_vkGetDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetDrmDisplayEXT" ) );
9268
9269	//=== VK_EXT_private_data ===
9270	vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT( vkGetInstanceProcAddr( instance, "vkCreatePrivateDataSlotEXT" ) );
9271	if ( !vkCreatePrivateDataSlot ) vkCreatePrivateDataSlot = vkCreatePrivateDataSlotEXT;
9272	vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT( vkGetInstanceProcAddr( instance, "vkDestroyPrivateDataSlotEXT" ) );
9273	if ( !vkDestroyPrivateDataSlot ) vkDestroyPrivateDataSlot = vkDestroyPrivateDataSlotEXT;
9274	vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetInstanceProcAddr( instance, "vkSetPrivateDataEXT" ) );
9275	if ( !vkSetPrivateData ) vkSetPrivateData = vkSetPrivateDataEXT;
9276	vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetInstanceProcAddr( instance, "vkGetPrivateDataEXT" ) );
9277	if ( !vkGetPrivateData ) vkGetPrivateData = vkGetPrivateDataEXT;
9278
9279	#if defined( VK_ENABLE_BETA_EXTENSIONS )
9280	//=== VK_KHR_video_encode_queue ===
9281	vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetInstanceProcAddr( instance, "vkCmdEncodeVideoKHR" ) );
9282	#endif /*VK_ENABLE_BETA_EXTENSIONS*/
9283
9284	#if defined( VK_USE_PLATFORM_METAL_EXT )
9285	//=== VK_EXT_metal_objects ===
9286	vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetInstanceProcAddr( instance, "vkExportMetalObjectsEXT" ) );
9287	#endif /*VK_USE_PLATFORM_METAL_EXT*/
9288
9289	//=== VK_KHR_synchronization2 ===
9290	vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetInstanceProcAddr( instance, "vkCmdSetEvent2KHR" ) );
9291	if ( !vkCmdSetEvent2 ) vkCmdSetEvent2 = vkCmdSetEvent2KHR;
9292	vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetInstanceProcAddr( instance, "vkCmdResetEvent2KHR" ) );
9293	if ( !vkCmdResetEvent2 ) vkCmdResetEvent2 = vkCmdResetEvent2KHR;
9294	vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents2KHR" ) );
9295	if ( !vkCmdWaitEvents2 ) vkCmdWaitEvents2 = vkCmdWaitEvents2KHR;
9296	vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier2KHR" ) );
9297	if ( !vkCmdPipelineBarrier2 ) vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR;
9298	vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp2KHR" ) );
9299	if ( !vkCmdWriteTimestamp2 ) vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR;
9300	vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetInstanceProcAddr( instance, "vkQueueSubmit2KHR" ) );
9301	if ( !vkQueueSubmit2 ) vkQueueSubmit2 = vkQueueSubmit2KHR;
9302	vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarker2AMD" ) );
9303	vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointData2NV" ) );
9304
9305	//=== VK_EXT_descriptor_buffer ===
9306	vkGetDescriptorSetLayoutSizeEXT = PFN_vkGetDescriptorSetLayoutSizeEXT( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSizeEXT" ) );
9307	vkGetDescriptorSetLayoutBindingOffsetEXT = PFN_vkGetDescriptorSetLayoutBindingOffsetEXT( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutBindingOffsetEXT" ) );
9308	vkGetDescriptorEXT = PFN_vkGetDescriptorEXT( vkGetInstanceProcAddr( instance, "vkGetDescriptorEXT" ) );
9309	vkCmdBindDescriptorBuffersEXT = PFN_vkCmdBindDescriptorBuffersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBuffersEXT" ) );
9310	vkCmdSetDescriptorBufferOffsetsEXT = PFN_vkCmdSetDescriptorBufferOffsetsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDescriptorBufferOffsetsEXT" ) );
9311	vkCmdBindDescriptorBufferEmbeddedSamplersEXT = PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT" ) );
9312	vkGetBufferOpaqueCaptureDescriptorDataEXT = PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureDescriptorDataEXT" ) );
9313	vkGetImageOpaqueCaptureDescriptorDataEXT = PFN_vkGetImageOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetImageOpaqueCaptureDescriptorDataEXT" ) );
9314	vkGetImageViewOpaqueCaptureDescriptorDataEXT = PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetImageViewOpaqueCaptureDescriptorDataEXT" ) );
9315	vkGetSamplerOpaqueCaptureDescriptorDataEXT = PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetSamplerOpaqueCaptureDescriptorDataEXT" ) );
9316	vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) );
9317
9318	//=== VK_NV_fragment_shading_rate_enums ===
9319	vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetInstanceProcAddr( instance, "vkCmdSetFragmentShadingRateEnumNV" ) );
9320
9321	//=== VK_EXT_mesh_shader ===
9322	vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksEXT" ) );
9323	vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectEXT" ) );
9324	vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountEXT" ) );
9325
9326	//=== VK_KHR_copy_commands2 ===
9327	vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer2KHR" ) );
9328	if ( !vkCmdCopyBuffer2 ) vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR;
9329	vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyImage2KHR" ) );
9330	if ( !vkCmdCopyImage2 ) vkCmdCopyImage2 = vkCmdCopyImage2KHR;
9331	vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage2KHR" ) );
9332	if ( !vkCmdCopyBufferToImage2 ) vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR;
9333	vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer2KHR" ) );
9334	if ( !vkCmdCopyImageToBuffer2 ) vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR;
9335	vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdBlitImage2KHR" ) );
9336	if ( !vkCmdBlitImage2 ) vkCmdBlitImage2 = vkCmdBlitImage2KHR;
9337	vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdResolveImage2KHR" ) );
9338	if ( !vkCmdResolveImage2 ) vkCmdResolveImage2 = vkCmdResolveImage2KHR;
9339
9340	//=== VK_EXT_image_compression_control ===
9341	vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout2EXT" ) );
9342
9343	//=== VK_EXT_device_fault ===
9344	vkGetDeviceFaultInfoEXT = PFN_vkGetDeviceFaultInfoEXT( vkGetInstanceProcAddr( instance, "vkGetDeviceFaultInfoEXT" ) );
9345
9346	#if defined( VK_USE_PLATFORM_WIN32_KHR )
9347	//=== VK_NV_acquire_winrt_display ===
9348	vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) );
9349	vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) );
9350	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
9351
9352	#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
9353	//=== VK_EXT_directfb_surface ===
9354	vkCreateDirectFBSurfaceEXT = PFN_vkCreateDirectFBSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateDirectFBSurfaceEXT" ) );
9355	vkGetPhysicalDeviceDirectFBPresentationSupportEXT = PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT" ) );
9356	#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
9357
9358	//=== VK_KHR_ray_tracing_pipeline ===
9359	vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysKHR" ) );
9360	vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR( vkGetInstanceProcAddr( instance, "vkCreateRayTracingPipelinesKHR" ) );
9361	vkGetRayTracingShaderGroupHandlesKHR = PFN_vkGetRayTracingShaderGroupHandlesKHR( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesKHR" ) );
9362	vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( vkGetInstanceProcAddr( instance, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) );
9363	vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysIndirectKHR" ) );
9364	vkGetRayTracingShaderGroupStackSizeKHR = PFN_vkGetRayTracingShaderGroupStackSizeKHR( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupStackSizeKHR" ) );
9365	vkCmdSetRayTracingPipelineStackSizeKHR = PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetInstanceProcAddr( instance, "vkCmdSetRayTracingPipelineStackSizeKHR" ) );
9366
9367	//=== VK_EXT_vertex_input_dynamic_state ===
9368	vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetInstanceProcAddr( instance, "vkCmdSetVertexInputEXT" ) );
9369
9370	#if defined( VK_USE_PLATFORM_FUCHSIA )
9371	//=== VK_FUCHSIA_external_memory ===
9372	vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetMemoryZirconHandleFUCHSIA" ) );
9373	vkGetMemoryZirconHandlePropertiesFUCHSIA = PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) );
9374	#endif /*VK_USE_PLATFORM_FUCHSIA*/
9375
9376	#if defined( VK_USE_PLATFORM_FUCHSIA )
9377	//=== VK_FUCHSIA_external_semaphore ===
9378	vkImportSemaphoreZirconHandleFUCHSIA = PFN_vkImportSemaphoreZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkImportSemaphoreZirconHandleFUCHSIA" ) );
9379	vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetSemaphoreZirconHandleFUCHSIA" ) );
9380	#endif /*VK_USE_PLATFORM_FUCHSIA*/
9381
9382	#if defined( VK_USE_PLATFORM_FUCHSIA )
9383	//=== VK_FUCHSIA_buffer_collection ===
9384	vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateBufferCollectionFUCHSIA" ) );
9385	vkSetBufferCollectionImageConstraintsFUCHSIA = PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( vkGetInstanceProcAddr( instance, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) );
9386	vkSetBufferCollectionBufferConstraintsFUCHSIA = PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( vkGetInstanceProcAddr( instance, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) );
9387	vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA( vkGetInstanceProcAddr( instance, "vkDestroyBufferCollectionFUCHSIA" ) );
9388	vkGetBufferCollectionPropertiesFUCHSIA = PFN_vkGetBufferCollectionPropertiesFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetBufferCollectionPropertiesFUCHSIA" ) );
9389	#endif /*VK_USE_PLATFORM_FUCHSIA*/
9390
9391	//=== VK_HUAWEI_subpass_shading ===
9392	vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( vkGetInstanceProcAddr( instance, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) );
9393	vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdSubpassShadingHUAWEI" ) );
9394
9395	//=== VK_HUAWEI_invocation_mask ===
9396	vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdBindInvocationMaskHUAWEI" ) );
9397
9398	//=== VK_NV_external_memory_rdma ===
9399	vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV( vkGetInstanceProcAddr( instance, "vkGetMemoryRemoteAddressNV" ) );
9400
9401	//=== VK_EXT_pipeline_properties ===
9402	vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPipelinePropertiesEXT" ) );
9403
9404	//=== VK_EXT_extended_dynamic_state2 ===
9405	vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPatchControlPointsEXT" ) );
9406	vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizerDiscardEnableEXT" ) );
9407	if ( !vkCmdSetRasterizerDiscardEnable ) vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT;
9408	vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBiasEnableEXT" ) );
9409	if ( !vkCmdSetDepthBiasEnable ) vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT;
9410	vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLogicOpEXT" ) );
9411	vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveRestartEnableEXT" ) );
9412	if ( !vkCmdSetPrimitiveRestartEnable ) vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT;
9413
9414	#if defined( VK_USE_PLATFORM_SCREEN_QNX )
9415	//=== VK_QNX_screen_surface ===
9416	vkCreateScreenSurfaceQNX = PFN_vkCreateScreenSurfaceQNX( vkGetInstanceProcAddr( instance, "vkCreateScreenSurfaceQNX" ) );
9417	vkGetPhysicalDeviceScreenPresentationSupportQNX = PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX" ) );
9418	#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
9419
9420	//=== VK_EXT_color_write_enable ===
9421	vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorWriteEnableEXT" ) );
9422
9423	//=== VK_KHR_ray_tracing_maintenance1 ===
9424	vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysIndirect2KHR" ) );
9425
9426	//=== VK_EXT_multi_draw ===
9427	vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMultiEXT" ) );
9428	vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMultiIndexedEXT" ) );
9429
9430	//=== VK_EXT_opacity_micromap ===
9431	vkCreateMicromapEXT = PFN_vkCreateMicromapEXT( vkGetInstanceProcAddr( instance, "vkCreateMicromapEXT" ) );
9432	vkDestroyMicromapEXT = PFN_vkDestroyMicromapEXT( vkGetInstanceProcAddr( instance, "vkDestroyMicromapEXT" ) );
9433	vkCmdBuildMicromapsEXT = PFN_vkCmdBuildMicromapsEXT( vkGetInstanceProcAddr( instance, "vkCmdBuildMicromapsEXT" ) );
9434	vkBuildMicromapsEXT = PFN_vkBuildMicromapsEXT( vkGetInstanceProcAddr( instance, "vkBuildMicromapsEXT" ) );
9435	vkCopyMicromapEXT = PFN_vkCopyMicromapEXT( vkGetInstanceProcAddr( instance, "vkCopyMicromapEXT" ) );
9436	vkCopyMicromapToMemoryEXT = PFN_vkCopyMicromapToMemoryEXT( vkGetInstanceProcAddr( instance, "vkCopyMicromapToMemoryEXT" ) );
9437	vkCopyMemoryToMicromapEXT = PFN_vkCopyMemoryToMicromapEXT( vkGetInstanceProcAddr( instance, "vkCopyMemoryToMicromapEXT" ) );
9438	vkWriteMicromapsPropertiesEXT = PFN_vkWriteMicromapsPropertiesEXT( vkGetInstanceProcAddr( instance, "vkWriteMicromapsPropertiesEXT" ) );
9439	vkCmdCopyMicromapEXT = PFN_vkCmdCopyMicromapEXT( vkGetInstanceProcAddr( instance, "vkCmdCopyMicromapEXT" ) );
9440	vkCmdCopyMicromapToMemoryEXT = PFN_vkCmdCopyMicromapToMemoryEXT( vkGetInstanceProcAddr( instance, "vkCmdCopyMicromapToMemoryEXT" ) );
9441	vkCmdCopyMemoryToMicromapEXT = PFN_vkCmdCopyMemoryToMicromapEXT( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToMicromapEXT" ) );
9442	vkCmdWriteMicromapsPropertiesEXT = PFN_vkCmdWriteMicromapsPropertiesEXT( vkGetInstanceProcAddr( instance, "vkCmdWriteMicromapsPropertiesEXT" ) );
9443	vkGetDeviceMicromapCompatibilityEXT = PFN_vkGetDeviceMicromapCompatibilityEXT( vkGetInstanceProcAddr( instance, "vkGetDeviceMicromapCompatibilityEXT" ) );
9444	vkGetMicromapBuildSizesEXT = PFN_vkGetMicromapBuildSizesEXT( vkGetInstanceProcAddr( instance, "vkGetMicromapBuildSizesEXT" ) );
9445
9446	//=== VK_EXT_pageable_device_local_memory ===
9447	vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT( vkGetInstanceProcAddr( instance, "vkSetDeviceMemoryPriorityEXT" ) );
9448
9449	//=== VK_KHR_maintenance4 ===
9450	vkGetDeviceBufferMemoryRequirementsKHR = PFN_vkGetDeviceBufferMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceBufferMemoryRequirementsKHR" ) );
9451	if ( !vkGetDeviceBufferMemoryRequirements ) vkGetDeviceBufferMemoryRequirements = vkGetDeviceBufferMemoryRequirementsKHR;
9452	vkGetDeviceImageMemoryRequirementsKHR = PFN_vkGetDeviceImageMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceImageMemoryRequirementsKHR" ) );
9453	if ( !vkGetDeviceImageMemoryRequirements ) vkGetDeviceImageMemoryRequirements = vkGetDeviceImageMemoryRequirementsKHR;
9454	vkGetDeviceImageSparseMemoryRequirementsKHR = PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) );
9455	if ( !vkGetDeviceImageSparseMemoryRequirements ) vkGetDeviceImageSparseMemoryRequirements = vkGetDeviceImageSparseMemoryRequirementsKHR;
9456
9457	//=== VK_VALVE_descriptor_set_host_mapping ===
9458	vkGetDescriptorSetLayoutHostMappingInfoVALVE = PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutHostMappingInfoVALVE" ) );
9459	vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetHostMappingVALVE" ) );
9460
9461	//=== VK_NV_copy_memory_indirect ===
9462	vkCmdCopyMemoryIndirectNV = PFN_vkCmdCopyMemoryIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryIndirectNV" ) );
9463	vkCmdCopyMemoryToImageIndirectNV = PFN_vkCmdCopyMemoryToImageIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToImageIndirectNV" ) );
9464
9465	//=== VK_NV_memory_decompression ===
9466	vkCmdDecompressMemoryNV = PFN_vkCmdDecompressMemoryNV( vkGetInstanceProcAddr( instance, "vkCmdDecompressMemoryNV" ) );
9467	vkCmdDecompressMemoryIndirectCountNV = PFN_vkCmdDecompressMemoryIndirectCountNV( vkGetInstanceProcAddr( instance, "vkCmdDecompressMemoryIndirectCountNV" ) );
9468
9469	//=== VK_EXT_extended_dynamic_state3 ===
9470	vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetInstanceProcAddr( instance, "vkCmdSetTessellationDomainOriginEXT" ) );
9471	vkCmdSetDepthClampEnableEXT = PFN_vkCmdSetDepthClampEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClampEnableEXT" ) );
9472	vkCmdSetPolygonModeEXT = PFN_vkCmdSetPolygonModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPolygonModeEXT" ) );
9473	vkCmdSetRasterizationSamplesEXT = PFN_vkCmdSetRasterizationSamplesEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizationSamplesEXT" ) );
9474	vkCmdSetSampleMaskEXT = PFN_vkCmdSetSampleMaskEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleMaskEXT" ) );
9475	vkCmdSetAlphaToCoverageEnableEXT = PFN_vkCmdSetAlphaToCoverageEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetAlphaToCoverageEnableEXT" ) );
9476	vkCmdSetAlphaToOneEnableEXT = PFN_vkCmdSetAlphaToOneEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetAlphaToOneEnableEXT" ) );
9477	vkCmdSetLogicOpEnableEXT = PFN_vkCmdSetLogicOpEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLogicOpEnableEXT" ) );
9478	vkCmdSetColorBlendEnableEXT = PFN_vkCmdSetColorBlendEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendEnableEXT" ) );
9479	vkCmdSetColorBlendEquationEXT = PFN_vkCmdSetColorBlendEquationEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendEquationEXT" ) );
9480	vkCmdSetColorWriteMaskEXT = PFN_vkCmdSetColorWriteMaskEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorWriteMaskEXT" ) );
9481	vkCmdSetRasterizationStreamEXT = PFN_vkCmdSetRasterizationStreamEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizationStreamEXT" ) );
9482	vkCmdSetConservativeRasterizationModeEXT = PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetConservativeRasterizationModeEXT" ) );
9483	vkCmdSetExtraPrimitiveOverestimationSizeEXT = PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetExtraPrimitiveOverestimationSizeEXT" ) );
9484	vkCmdSetDepthClipEnableEXT = PFN_vkCmdSetDepthClipEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClipEnableEXT" ) );
9485	vkCmdSetSampleLocationsEnableEXT = PFN_vkCmdSetSampleLocationsEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEnableEXT" ) );
9486	vkCmdSetColorBlendAdvancedEXT = PFN_vkCmdSetColorBlendAdvancedEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendAdvancedEXT" ) );
9487	vkCmdSetProvokingVertexModeEXT = PFN_vkCmdSetProvokingVertexModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetProvokingVertexModeEXT" ) );
9488	vkCmdSetLineRasterizationModeEXT = PFN_vkCmdSetLineRasterizationModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineRasterizationModeEXT" ) );
9489	vkCmdSetLineStippleEnableEXT = PFN_vkCmdSetLineStippleEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEnableEXT" ) );
9490	vkCmdSetDepthClipNegativeOneToOneEXT = PFN_vkCmdSetDepthClipNegativeOneToOneEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClipNegativeOneToOneEXT" ) );
9491	vkCmdSetViewportWScalingEnableNV = PFN_vkCmdSetViewportWScalingEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWScalingEnableNV" ) );
9492	vkCmdSetViewportSwizzleNV = PFN_vkCmdSetViewportSwizzleNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportSwizzleNV" ) );
9493	vkCmdSetCoverageToColorEnableNV = PFN_vkCmdSetCoverageToColorEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageToColorEnableNV" ) );
9494	vkCmdSetCoverageToColorLocationNV = PFN_vkCmdSetCoverageToColorLocationNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageToColorLocationNV" ) );
9495	vkCmdSetCoverageModulationModeNV = PFN_vkCmdSetCoverageModulationModeNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageModulationModeNV" ) );
9496	vkCmdSetCoverageModulationTableEnableNV = PFN_vkCmdSetCoverageModulationTableEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageModulationTableEnableNV" ) );
9497	vkCmdSetCoverageModulationTableNV = PFN_vkCmdSetCoverageModulationTableNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageModulationTableNV" ) );
9498	vkCmdSetShadingRateImageEnableNV = PFN_vkCmdSetShadingRateImageEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetShadingRateImageEnableNV" ) );
9499	vkCmdSetRepresentativeFragmentTestEnableNV = PFN_vkCmdSetRepresentativeFragmentTestEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetRepresentativeFragmentTestEnableNV" ) );
9500	vkCmdSetCoverageReductionModeNV = PFN_vkCmdSetCoverageReductionModeNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageReductionModeNV" ) );
9501
9502	//=== VK_EXT_shader_module_identifier ===
9503	vkGetShaderModuleIdentifierEXT = PFN_vkGetShaderModuleIdentifierEXT( vkGetInstanceProcAddr( instance, "vkGetShaderModuleIdentifierEXT" ) );
9504	vkGetShaderModuleCreateInfoIdentifierEXT = PFN_vkGetShaderModuleCreateInfoIdentifierEXT( vkGetInstanceProcAddr( instance, "vkGetShaderModuleCreateInfoIdentifierEXT" ) );
9505
9506	//=== VK_NV_optical_flow ===
9507	vkGetPhysicalDeviceOpticalFlowImageFormatsNV = PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV" ) );
9508	vkCreateOpticalFlowSessionNV = PFN_vkCreateOpticalFlowSessionNV( vkGetInstanceProcAddr( instance, "vkCreateOpticalFlowSessionNV" ) );
9509	vkDestroyOpticalFlowSessionNV = PFN_vkDestroyOpticalFlowSessionNV( vkGetInstanceProcAddr( instance, "vkDestroyOpticalFlowSessionNV" ) );
9510	vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetInstanceProcAddr( instance, "vkBindOpticalFlowSessionImageNV" ) );
9511	vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetInstanceProcAddr( instance, "vkCmdOpticalFlowExecuteNV" ) );
9512
9513	//=== VK_QCOM_tile_properties ===
9514	vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetInstanceProcAddr( instance, "vkGetFramebufferTilePropertiesQCOM" ) );
9515	vkGetDynamicRenderingTilePropertiesQCOM = PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetInstanceProcAddr( instance, "vkGetDynamicRenderingTilePropertiesQCOM" ) );
9516
9517	}
9518
9519	void init( VULKAN_HPP_NAMESPACE::Device deviceCpp ) VULKAN_HPP_NOEXCEPT
9520	{
9521	VkDevice device = static_cast<VkDevice>(deviceCpp);
9522
9523
9524	//=== VK_VERSION_1_0 ===
9525	vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetDeviceProcAddr( device, "vkGetDeviceProcAddr" ) );
9526	vkDestroyDevice = PFN_vkDestroyDevice( vkGetDeviceProcAddr( device, "vkDestroyDevice" ) );
9527	vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) );
9528	vkQueueSubmit = PFN_vkQueueSubmit( vkGetDeviceProcAddr( device, "vkQueueSubmit" ) );
9529	vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) );
9530	vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetDeviceProcAddr( device, "vkDeviceWaitIdle" ) );
9531	vkAllocateMemory = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) );
9532	vkFreeMemory = PFN_vkFreeMemory( vkGetDeviceProcAddr( device, "vkFreeMemory" ) );
9533	vkMapMemory = PFN_vkMapMemory( vkGetDeviceProcAddr( device, "vkMapMemory" ) );
9534	vkUnmapMemory = PFN_vkUnmapMemory( vkGetDeviceProcAddr( device, "vkUnmapMemory" ) );
9535	vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkFlushMappedMemoryRanges" ) );
9536	vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkInvalidateMappedMemoryRanges" ) );
9537	vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) );
9538	vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) );
9539	vkBindImageMemory = PFN_vkBindImageMemory( vkGetDeviceProcAddr( device, "vkBindImageMemory" ) );
9540	vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements" ) );
9541	vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements" ) );
9542	vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements" ) );
9543	vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetDeviceProcAddr( device, "vkQueueBindSparse" ) );
9544	vkCreateFence = PFN_vkCreateFence( vkGetDeviceProcAddr( device, "vkCreateFence" ) );
9545	vkDestroyFence = PFN_vkDestroyFence( vkGetDeviceProcAddr( device, "vkDestroyFence" ) );
9546	vkResetFences = PFN_vkResetFences( vkGetDeviceProcAddr( device, "vkResetFences" ) );
9547	vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetDeviceProcAddr( device, "vkGetFenceStatus" ) );
9548	vkWaitForFences = PFN_vkWaitForFences( vkGetDeviceProcAddr( device, "vkWaitForFences" ) );
9549	vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetDeviceProcAddr( device, "vkCreateSemaphore" ) );
9550	vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetDeviceProcAddr( device, "vkDestroySemaphore" ) );
9551	vkCreateEvent = PFN_vkCreateEvent( vkGetDeviceProcAddr( device, "vkCreateEvent" ) );
9552	vkDestroyEvent = PFN_vkDestroyEvent( vkGetDeviceProcAddr( device, "vkDestroyEvent" ) );
9553	vkGetEventStatus = PFN_vkGetEventStatus( vkGetDeviceProcAddr( device, "vkGetEventStatus" ) );
9554	vkSetEvent = PFN_vkSetEvent( vkGetDeviceProcAddr( device, "vkSetEvent" ) );
9555	vkResetEvent = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) );
9556	vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetDeviceProcAddr( device, "vkCreateQueryPool" ) );
9557	vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetDeviceProcAddr( device, "vkDestroyQueryPool" ) );
9558	vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) );
9559	vkCreateBuffer = PFN_vkCreateBuffer( vkGetDeviceProcAddr( device, "vkCreateBuffer" ) );
9560	vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) );
9561	vkCreateBufferView = PFN_vkCreateBufferView( vkGetDeviceProcAddr( device, "vkCreateBufferView" ) );
9562	vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) );
9563	vkCreateImage = PFN_vkCreateImage( vkGetDeviceProcAddr( device, "vkCreateImage" ) );
9564	vkDestroyImage = PFN_vkDestroyImage( vkGetDeviceProcAddr( device, "vkDestroyImage" ) );
9565	vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) );
9566	vkCreateImageView = PFN_vkCreateImageView( vkGetDeviceProcAddr( device, "vkCreateImageView" ) );
9567	vkDestroyImageView = PFN_vkDestroyImageView( vkGetDeviceProcAddr( device, "vkDestroyImageView" ) );
9568	vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetDeviceProcAddr( device, "vkCreateShaderModule" ) );
9569	vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetDeviceProcAddr( device, "vkDestroyShaderModule" ) );
9570	vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetDeviceProcAddr( device, "vkCreatePipelineCache" ) );
9571	vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetDeviceProcAddr( device, "vkDestroyPipelineCache" ) );
9572	vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) );
9573	vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetDeviceProcAddr( device, "vkMergePipelineCaches" ) );
9574	vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetDeviceProcAddr( device, "vkCreateGraphicsPipelines" ) );
9575	vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) );
9576	vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetDeviceProcAddr( device, "vkDestroyPipeline" ) );
9577	vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetDeviceProcAddr( device, "vkCreatePipelineLayout" ) );
9578	vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetDeviceProcAddr( device, "vkDestroyPipelineLayout" ) );
9579	vkCreateSampler = PFN_vkCreateSampler( vkGetDeviceProcAddr( device, "vkCreateSampler" ) );
9580	vkDestroySampler = PFN_vkDestroySampler( vkGetDeviceProcAddr( device, "vkDestroySampler" ) );
9581	vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkCreateDescriptorSetLayout" ) );
9582	vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkDestroyDescriptorSetLayout" ) );
9583	vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) );
9584	vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetDeviceProcAddr( device, "vkDestroyDescriptorPool" ) );
9585	vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) );
9586	vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) );
9587	vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetDeviceProcAddr( device, "vkFreeDescriptorSets" ) );
9588	vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) );
9589	vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetDeviceProcAddr( device, "vkCreateFramebuffer" ) );
9590	vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetDeviceProcAddr( device, "vkDestroyFramebuffer" ) );
9591	vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetDeviceProcAddr( device, "vkCreateRenderPass" ) );
9592	vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetDeviceProcAddr( device, "vkDestroyRenderPass" ) );
9593	vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderAreaGranularity" ) );
9594	vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) );
9595	vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) );
9596	vkResetCommandPool = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) );
9597	vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) );
9598	vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetDeviceProcAddr( device, "vkFreeCommandBuffers" ) );
9599	vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) );
9600	vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) );
9601	vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) );
9602	vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetDeviceProcAddr( device, "vkCmdBindPipeline" ) );
9603	vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetDeviceProcAddr( device, "vkCmdSetViewport" ) );
9604	vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) );
9605	vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) );
9606	vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) );
9607	vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetDeviceProcAddr( device, "vkCmdSetBlendConstants" ) );
9608	vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) );
9609	vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) );
9610	vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilWriteMask" ) );
9611	vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetDeviceProcAddr( device, "vkCmdSetStencilReference" ) );
9612	vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets" ) );
9613	vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer" ) );
9614	vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers" ) );
9615	vkCmdDraw = PFN_vkCmdDraw( vkGetDeviceProcAddr( device, "vkCmdDraw" ) );
9616	vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetDeviceProcAddr( device, "vkCmdDrawIndexed" ) );
9617	vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndirect" ) );
9618	vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect" ) );
9619	vkCmdDispatch = PFN_vkCmdDispatch( vkGetDeviceProcAddr( device, "vkCmdDispatch" ) );
9620	vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect" ) );
9621	vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer" ) );
9622	vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetDeviceProcAddr( device, "vkCmdCopyImage" ) );
9623	vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetDeviceProcAddr( device, "vkCmdBlitImage" ) );
9624	vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage" ) );
9625	vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer" ) );
9626	vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetDeviceProcAddr( device, "vkCmdUpdateBuffer" ) );
9627	vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetDeviceProcAddr( device, "vkCmdFillBuffer" ) );
9628	vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetDeviceProcAddr( device, "vkCmdClearColorImage" ) );
9629	vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetDeviceProcAddr( device, "vkCmdClearDepthStencilImage" ) );
9630	vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetDeviceProcAddr( device, "vkCmdClearAttachments" ) );
9631	vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetDeviceProcAddr( device, "vkCmdResolveImage" ) );
9632	vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) );
9633	vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetDeviceProcAddr( device, "vkCmdResetEvent" ) );
9634	vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetDeviceProcAddr( device, "vkCmdWaitEvents" ) );
9635	vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier" ) );
9636	vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetDeviceProcAddr( device, "vkCmdBeginQuery" ) );
9637	vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetDeviceProcAddr( device, "vkCmdEndQuery" ) );
9638	vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetDeviceProcAddr( device, "vkCmdResetQueryPool" ) );
9639	vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) );
9640	vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) );
9641	vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetDeviceProcAddr( device, "vkCmdPushConstants" ) );
9642	vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) );
9643	vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetDeviceProcAddr( device, "vkCmdNextSubpass" ) );
9644	vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass" ) );
9645	vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetDeviceProcAddr( device, "vkCmdExecuteCommands" ) );
9646
9647	//=== VK_VERSION_1_1 ===
9648	vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) );
9649	vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) );
9650	vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) );
9651	vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) );
9652	vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) );
9653	vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) );
9654	vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) );
9655	vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) );
9656	vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) );
9657	vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetDeviceProcAddr( device, "vkGetDeviceQueue2" ) );
9658	vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) );
9659	vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) );
9660	vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplate" ) );
9661	vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplate" ) );
9662	vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) );
9663	vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) );
9664
9665	//=== VK_VERSION_1_2 ===
9666	vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCount" ) );
9667	vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCount" ) );
9668	vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetDeviceProcAddr( device, "vkCreateRenderPass2" ) );
9669	vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2" ) );
9670	vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2" ) );
9671	vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2" ) );
9672	vkResetQueryPool = PFN_vkResetQueryPool( vkGetDeviceProcAddr( device, "vkResetQueryPool" ) );
9673	vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValue" ) );
9674	vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetDeviceProcAddr( device, "vkWaitSemaphores" ) );
9675	vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetDeviceProcAddr( device, "vkSignalSemaphore" ) );
9676	vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddress" ) );
9677	vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddress" ) );
9678	vkGetDeviceMemoryOpaqueCaptureAddress = PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddress" ) );
9679
9680	//=== VK_VERSION_1_3 ===
9681	vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlot" ) );
9682	vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlot" ) );
9683	vkSetPrivateData = PFN_vkSetPrivateData( vkGetDeviceProcAddr( device, "vkSetPrivateData" ) );
9684	vkGetPrivateData = PFN_vkGetPrivateData( vkGetDeviceProcAddr( device, "vkGetPrivateData" ) );
9685	vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetDeviceProcAddr( device, "vkCmdSetEvent2" ) );
9686	vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetDeviceProcAddr( device, "vkCmdResetEvent2" ) );
9687	vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2" ) );
9688	vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2" ) );
9689	vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2" ) );
9690	vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetDeviceProcAddr( device, "vkQueueSubmit2" ) );
9691	vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2" ) );
9692	vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetDeviceProcAddr( device, "vkCmdCopyImage2" ) );
9693	vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2" ) );
9694	vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2" ) );
9695	vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetDeviceProcAddr( device, "vkCmdBlitImage2" ) );
9696	vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetDeviceProcAddr( device, "vkCmdResolveImage2" ) );
9697	vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetDeviceProcAddr( device, "vkCmdBeginRendering" ) );
9698	vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetDeviceProcAddr( device, "vkCmdEndRendering" ) );
9699	vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetDeviceProcAddr( device, "vkCmdSetCullMode" ) );
9700	vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetDeviceProcAddr( device, "vkCmdSetFrontFace" ) );
9701	vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopology" ) );
9702	vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCount" ) );
9703	vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCount" ) );
9704	vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2" ) );
9705	vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnable" ) );
9706	vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnable" ) );
9707	vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOp" ) );
9708	vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnable" ) );
9709	vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnable" ) );
9710	vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetDeviceProcAddr( device, "vkCmdSetStencilOp" ) );
9711	vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnable" ) );
9712	vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnable" ) );
9713	vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnable" ) );
9714	vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirements" ) );
9715	vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirements" ) );
9716	vkGetDeviceImageSparseMemoryRequirements = PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirements" ) );
9717
9718	//=== VK_KHR_swapchain ===
9719	vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetDeviceProcAddr( device, "vkCreateSwapchainKHR" ) );
9720	vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetDeviceProcAddr( device, "vkDestroySwapchainKHR" ) );
9721	vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainImagesKHR" ) );
9722	vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) );
9723	vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) );
9724	vkGetDeviceGroupPresentCapabilitiesKHR = PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) );
9725	vkGetDeviceGroupSurfacePresentModesKHR = PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) );
9726	vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) );
9727
9728	//=== VK_KHR_display_swapchain ===
9729	vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetDeviceProcAddr( device, "vkCreateSharedSwapchainsKHR" ) );
9730
9731	//=== VK_EXT_debug_marker ===
9732	vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectTagEXT" ) );
9733	vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectNameEXT" ) );
9734	vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerBeginEXT" ) );
9735	vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) );
9736	vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerInsertEXT" ) );
9737
9738	//=== VK_KHR_video_queue ===
9739	vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionKHR" ) );
9740	vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionKHR" ) );
9741	vkGetVideoSessionMemoryRequirementsKHR = PFN_vkGetVideoSessionMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetVideoSessionMemoryRequirementsKHR" ) );
9742	vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR( vkGetDeviceProcAddr( device, "vkBindVideoSessionMemoryKHR" ) );
9743	vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionParametersKHR" ) );
9744	vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkUpdateVideoSessionParametersKHR" ) );
9745	vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionParametersKHR" ) );
9746	vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginVideoCodingKHR" ) );
9747	vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdEndVideoCodingKHR" ) );
9748	vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdControlVideoCodingKHR" ) );
9749
9750	//=== VK_KHR_video_decode_queue ===
9751	vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdDecodeVideoKHR" ) );
9752
9753	//=== VK_EXT_transform_feedback ===
9754	vkCmdBindTransformFeedbackBuffersEXT = PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffersEXT" ) );
9755	vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedbackEXT" ) );
9756	vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedbackEXT" ) );
9757	vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdBeginQueryIndexedEXT" ) );
9758	vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdEndQueryIndexedEXT" ) );
9759	vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCountEXT" ) );
9760
9761	//=== VK_NVX_binary_import ===
9762	vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetDeviceProcAddr( device, "vkCreateCuModuleNVX" ) );
9763	vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetDeviceProcAddr( device, "vkCreateCuFunctionNVX" ) );
9764	vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetDeviceProcAddr( device, "vkDestroyCuModuleNVX" ) );
9765	vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetDeviceProcAddr( device, "vkDestroyCuFunctionNVX" ) );
9766	vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetDeviceProcAddr( device, "vkCmdCuLaunchKernelNVX" ) );
9767
9768	//=== VK_NVX_image_view_handle ===
9769	vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) );
9770	vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) );
9771
9772	//=== VK_AMD_draw_indirect_count ===
9773	vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) );
9774	if ( !vkCmdDrawIndirectCount ) vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD;
9775	vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountAMD" ) );
9776	if ( !vkCmdDrawIndexedIndirectCount ) vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD;
9777
9778	//=== VK_AMD_shader_info ===
9779	vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetDeviceProcAddr( device, "vkGetShaderInfoAMD" ) );
9780
9781	//=== VK_KHR_dynamic_rendering ===
9782	vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderingKHR" ) );
9783	if ( !vkCmdBeginRendering ) vkCmdBeginRendering = vkCmdBeginRenderingKHR;
9784	vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderingKHR" ) );
9785	if ( !vkCmdEndRendering ) vkCmdEndRendering = vkCmdEndRenderingKHR;
9786
9787	#if defined( VK_USE_PLATFORM_WIN32_KHR )
9788	//=== VK_NV_external_memory_win32 ===
9789	vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ) );
9790	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
9791
9792	//=== VK_KHR_device_group ===
9793	vkGetDeviceGroupPeerMemoryFeaturesKHR = PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) );
9794	if ( !vkGetDeviceGroupPeerMemoryFeatures ) vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR;
9795	vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMaskKHR" ) );
9796	if ( !vkCmdSetDeviceMask ) vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR;
9797	vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetDeviceProcAddr( device, "vkCmdDispatchBaseKHR" ) );
9798	if ( !vkCmdDispatchBase ) vkCmdDispatchBase = vkCmdDispatchBaseKHR;
9799
9800	//=== VK_KHR_maintenance1 ===
9801	vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) );
9802	if ( !vkTrimCommandPool ) vkTrimCommandPool = vkTrimCommandPoolKHR;
9803
9804	#if defined( VK_USE_PLATFORM_WIN32_KHR )
9805	//=== VK_KHR_external_memory_win32 ===
9806	vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ) );
9807	vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ) );
9808	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
9809
9810	//=== VK_KHR_external_memory_fd ===
9811	vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdKHR" ) );
9812	vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdPropertiesKHR" ) );
9813
9814	#if defined( VK_USE_PLATFORM_WIN32_KHR )
9815	//=== VK_KHR_external_semaphore_win32 ===
9816	vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ) );
9817	vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ) );
9818	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
9819
9820	//=== VK_KHR_external_semaphore_fd ===
9821	vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreFdKHR" ) );
9822	vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreFdKHR" ) );
9823
9824	//=== VK_KHR_push_descriptor ===
9825	vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetKHR" ) );
9826	vkCmdPushDescriptorSetWithTemplateKHR = PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplateKHR" ) );
9827
9828	//=== VK_EXT_conditional_rendering ===
9829	vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) );
9830	vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdEndConditionalRenderingEXT" ) );
9831
9832	//=== VK_KHR_descriptor_update_template ===
9833	vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplateKHR" ) );
9834	if ( !vkCreateDescriptorUpdateTemplate ) vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR;
9835	vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplateKHR" ) );
9836	if ( !vkDestroyDescriptorUpdateTemplate ) vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR;
9837	vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplateKHR" ) );
9838	if ( !vkUpdateDescriptorSetWithTemplate ) vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR;
9839
9840	//=== VK_NV_clip_space_w_scaling ===
9841	vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingNV" ) );
9842
9843	//=== VK_EXT_display_control ===
9844	vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) );
9845	vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) );
9846	vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) );
9847	vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainCounterEXT" ) );
9848
9849	//=== VK_GOOGLE_display_timing ===
9850	vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) );
9851	vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) );
9852
9853	//=== VK_EXT_discard_rectangles ===
9854	vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) );
9855
9856	//=== VK_EXT_hdr_metadata ===
9857	vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) );
9858
9859	//=== VK_KHR_create_renderpass2 ===
9860	vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCreateRenderPass2KHR" ) );
9861	if ( !vkCreateRenderPass2 ) vkCreateRenderPass2 = vkCreateRenderPass2KHR;
9862	vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2KHR" ) );
9863	if ( !vkCmdBeginRenderPass2 ) vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR;
9864	vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2KHR" ) );
9865	if ( !vkCmdNextSubpass2 ) vkCmdNextSubpass2 = vkCmdNextSubpass2KHR;
9866	vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2KHR" ) );
9867	if ( !vkCmdEndRenderPass2 ) vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR;
9868
9869	//=== VK_KHR_shared_presentable_image ===
9870	vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainStatusKHR" ) );
9871
9872	#if defined( VK_USE_PLATFORM_WIN32_KHR )
9873	//=== VK_KHR_external_fence_win32 ===
9874	vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ) );
9875	vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ) );
9876	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
9877
9878	//=== VK_KHR_external_fence_fd ===
9879	vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetDeviceProcAddr( device, "vkImportFenceFdKHR" ) );
9880	vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetDeviceProcAddr( device, "vkGetFenceFdKHR" ) );
9881
9882	//=== VK_KHR_performance_query ===
9883	vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetDeviceProcAddr( device, "vkAcquireProfilingLockKHR" ) );
9884	vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetDeviceProcAddr( device, "vkReleaseProfilingLockKHR" ) );
9885
9886	//=== VK_EXT_debug_utils ===
9887	vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) );
9888	vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) );
9889	vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueBeginDebugUtilsLabelEXT" ) );
9890	vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueEndDebugUtilsLabelEXT" ) );
9891	vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueInsertDebugUtilsLabelEXT" ) );
9892	vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) );
9893	vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdEndDebugUtilsLabelEXT" ) );
9894	vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdInsertDebugUtilsLabelEXT" ) );
9895
9896	#if defined( VK_USE_PLATFORM_ANDROID_KHR )
9897	//=== VK_ANDROID_external_memory_android_hardware_buffer ===
9898	vkGetAndroidHardwareBufferPropertiesANDROID = PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ) );
9899	vkGetMemoryAndroidHardwareBufferANDROID = PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) );
9900	#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
9901
9902	//=== VK_EXT_sample_locations ===
9903	vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) );
9904
9905	//=== VK_KHR_get_memory_requirements2 ===
9906	vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2KHR" ) );
9907	if ( !vkGetImageMemoryRequirements2 ) vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR;
9908	vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2KHR" ) );
9909	if ( !vkGetBufferMemoryRequirements2 ) vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR;
9910	vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2KHR" ) );
9911	if ( !vkGetImageSparseMemoryRequirements2 ) vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR;
9912
9913	//=== VK_KHR_acceleration_structure ===
9914	vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureKHR" ) );
9915	vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureKHR" ) );
9916	vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresKHR" ) );
9917	vkCmdBuildAccelerationStructuresIndirectKHR = PFN_vkCmdBuildAccelerationStructuresIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresIndirectKHR" ) );
9918	vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkBuildAccelerationStructuresKHR" ) );
9919	vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureKHR" ) );
9920	vkCopyAccelerationStructureToMemoryKHR = PFN_vkCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureToMemoryKHR" ) );
9921	vkCopyMemoryToAccelerationStructureKHR = PFN_vkCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyMemoryToAccelerationStructureKHR" ) );
9922	vkWriteAccelerationStructuresPropertiesKHR = PFN_vkWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkWriteAccelerationStructuresPropertiesKHR" ) );
9923	vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureKHR" ) );
9924	vkCmdCopyAccelerationStructureToMemoryKHR = PFN_vkCmdCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureToMemoryKHR" ) );
9925	vkCmdCopyMemoryToAccelerationStructureKHR = PFN_vkCmdCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToAccelerationStructureKHR" ) );
9926	vkGetAccelerationStructureDeviceAddressKHR = PFN_vkGetAccelerationStructureDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureDeviceAddressKHR" ) );
9927	vkCmdWriteAccelerationStructuresPropertiesKHR = PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) );
9928	vkGetDeviceAccelerationStructureCompatibilityKHR = PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( vkGetDeviceProcAddr( device, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) );
9929	vkGetAccelerationStructureBuildSizesKHR = PFN_vkGetAccelerationStructureBuildSizesKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureBuildSizesKHR" ) );
9930
9931	//=== VK_KHR_sampler_ycbcr_conversion ===
9932	vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversionKHR" ) );
9933	if ( !vkCreateSamplerYcbcrConversion ) vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR;
9934	vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversionKHR" ) );
9935	if ( !vkDestroySamplerYcbcrConversion ) vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR;
9936
9937	//=== VK_KHR_bind_memory2 ===
9938	vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetDeviceProcAddr( device, "vkBindBufferMemory2KHR" ) );
9939	if ( !vkBindBufferMemory2 ) vkBindBufferMemory2 = vkBindBufferMemory2KHR;
9940	vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetDeviceProcAddr( device, "vkBindImageMemory2KHR" ) );
9941	if ( !vkBindImageMemory2 ) vkBindImageMemory2 = vkBindImageMemory2KHR;
9942
9943	//=== VK_EXT_image_drm_format_modifier ===
9944	vkGetImageDrmFormatModifierPropertiesEXT = PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetImageDrmFormatModifierPropertiesEXT" ) );
9945
9946	//=== VK_EXT_validation_cache ===
9947	vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetDeviceProcAddr( device, "vkCreateValidationCacheEXT" ) );
9948	vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetDeviceProcAddr( device, "vkDestroyValidationCacheEXT" ) );
9949	vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetDeviceProcAddr( device, "vkMergeValidationCachesEXT" ) );
9950	vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetDeviceProcAddr( device, "vkGetValidationCacheDataEXT" ) );
9951
9952	//=== VK_NV_shading_rate_image ===
9953	vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetDeviceProcAddr( device, "vkCmdBindShadingRateImageNV" ) );
9954	vkCmdSetViewportShadingRatePaletteNV = PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportShadingRatePaletteNV" ) );
9955	vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetDeviceProcAddr( device, "vkCmdSetCoarseSampleOrderNV" ) );
9956
9957	//=== VK_NV_ray_tracing ===
9958	vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureNV" ) );
9959	vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureNV" ) );
9960	vkGetAccelerationStructureMemoryRequirementsNV = PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureMemoryRequirementsNV" ) );
9961	vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryNV" ) );
9962	vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructureNV" ) );
9963	vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureNV" ) );
9964	vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetDeviceProcAddr( device, "vkCmdTraceRaysNV" ) );
9965	vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesNV" ) );
9966	vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) );
9967	if ( !vkGetRayTracingShaderGroupHandlesKHR ) vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV;
9968	vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureHandleNV" ) );
9969	vkCmdWriteAccelerationStructuresPropertiesNV = PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesNV" ) );
9970	vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetDeviceProcAddr( device, "vkCompileDeferredNV" ) );
9971
9972	//=== VK_KHR_maintenance3 ===
9973	vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupportKHR" ) );
9974	if ( !vkGetDescriptorSetLayoutSupport ) vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR;
9975
9976	//=== VK_KHR_draw_indirect_count ===
9977	vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountKHR" ) );
9978	if ( !vkCmdDrawIndirectCount ) vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR;
9979	vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountKHR" ) );
9980	if ( !vkCmdDrawIndexedIndirectCount ) vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR;
9981
9982	//=== VK_EXT_external_memory_host ===
9983	vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) );
9984
9985	//=== VK_AMD_buffer_marker ===
9986	vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarkerAMD" ) );
9987
9988	//=== VK_EXT_calibrated_timestamps ===
9989	vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) );
9990
9991	//=== VK_NV_mesh_shader ===
9992	vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksNV" ) );
9993	vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectNV" ) );
9994	vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountNV" ) );
9995
9996	//=== VK_NV_scissor_exclusive ===
9997	vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) );
9998
9999	//=== VK_NV_device_diagnostic_checkpoints ===
10000	vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetDeviceProcAddr( device, "vkCmdSetCheckpointNV" ) );
10001	vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointDataNV" ) );
10002
10003	//=== VK_KHR_timeline_semaphore ===
10004	vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValueKHR" ) );
10005	if ( !vkGetSemaphoreCounterValue ) vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR;
10006	vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetDeviceProcAddr( device, "vkWaitSemaphoresKHR" ) );
10007	if ( !vkWaitSemaphores ) vkWaitSemaphores = vkWaitSemaphoresKHR;
10008	vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetDeviceProcAddr( device, "vkSignalSemaphoreKHR" ) );
10009	if ( !vkSignalSemaphore ) vkSignalSemaphore = vkSignalSemaphoreKHR;
10010
10011	//=== VK_INTEL_performance_query ===
10012	vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkInitializePerformanceApiINTEL" ) );
10013	vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) );
10014	vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) );
10015	vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) );
10016	vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) );
10017	vkAcquirePerformanceConfigurationINTEL = PFN_vkAcquirePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) );
10018	vkReleasePerformanceConfigurationINTEL = PFN_vkReleasePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) );
10019	vkQueueSetPerformanceConfigurationINTEL = PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkQueueSetPerformanceConfigurationINTEL" ) );
10020	vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetDeviceProcAddr( device, "vkGetPerformanceParameterINTEL" ) );
10021
10022	//=== VK_AMD_display_native_hdr ===
10023	vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) );
10024
10025	//=== VK_KHR_fragment_shading_rate ===
10026	vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateKHR" ) );
10027
10028	//=== VK_EXT_buffer_device_address ===
10029	vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) );
10030	if ( !vkGetBufferDeviceAddress ) vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT;
10031
10032	//=== VK_KHR_present_wait ===
10033	vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetDeviceProcAddr( device, "vkWaitForPresentKHR" ) );
10034
10035	#if defined( VK_USE_PLATFORM_WIN32_KHR )
10036	//=== VK_EXT_full_screen_exclusive ===
10037	vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) );
10038	vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) );
10039	vkGetDeviceGroupSurfacePresentModes2EXT = PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ) );
10040	#endif /*VK_USE_PLATFORM_WIN32_KHR*/
10041
10042	//=== VK_KHR_buffer_device_address ===
10043	vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressKHR" ) );
10044	if ( !vkGetBufferDeviceAddress ) vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR;
10045	vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddressKHR" ) );
10046	if ( !vkGetBufferOpaqueCaptureAddress ) vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR;
10047	vkGetDeviceMemoryOpaqueCaptureAddressKHR = PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) );
10048	if ( !vkGetDeviceMemoryOpaqueCaptureAddress ) vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR;
10049
10050	//=== VK_EXT_line_rasterization ===
10051	vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) );
10052
10053	//=== VK_EXT_host_query_reset ===
10054	vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) );
10055	if ( !vkResetQueryPool ) vkResetQueryPool = vkResetQueryPoolEXT;
10056
10057	//=== VK_EXT_extended_dynamic_state ===
10058	vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetCullModeEXT" ) );
10059	if ( !vkCmdSetCullMode ) vkCmdSetCullMode = vkCmdSetCullModeEXT;
10060	vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetDeviceProcAddr( device, "vkCmdSetFrontFaceEXT" ) );
10061	if ( !vkCmdSetFrontFace ) vkCmdSetFrontFace = vkCmdSetFrontFaceEXT;
10062	vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopologyEXT" ) );
10063	if ( !vkCmdSetPrimitiveTopology ) vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT;
10064	vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCountEXT" ) );
10065	if ( !vkCmdSetViewportWithCount ) vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT;
10066	vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCountEXT" ) );
10067	if ( !vkCmdSetScissorWithCount ) vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT;
10068	vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2EXT" ) );
10069	if ( !vkCmdBindVertexBuffers2 ) vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT;
10070	vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnableEXT" ) );
10071	if ( !vkCmdSetDepthTestEnable ) vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT;
10072	vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnableEXT" ) );
10073	if ( !vkCmdSetDepthWriteEnable ) vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT;
10074	vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOpEXT" ) );
10075	if ( !vkCmdSetDepthCompareOp ) vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT;
10076	vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnableEXT" ) );
10077	if ( !vkCmdSetDepthBoundsTestEnable ) vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT;
10078	vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnableEXT" ) );
10079	if ( !vkCmdSetStencilTestEnable ) vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT;
10080	vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilOpEXT" ) );
10081	if ( !vkCmdSetStencilOp ) vkCmdSetStencilOp = vkCmdSetStencilOpEXT;
10082
10083	//=== VK_KHR_deferred_host_operations ===
10084	vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkCreateDeferredOperationKHR" ) );
10085	vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkDestroyDeferredOperationKHR" ) );
10086	vkGetDeferredOperationMaxConcurrencyKHR = PFN_vkGetDeferredOperationMaxConcurrencyKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationMaxConcurrencyKHR" ) );
10087	vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationResultKHR" ) );
10088	vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR( vkGetDeviceProcAddr( device, "vkDeferredOperationJoinKHR" ) );
10089
10090	//=== VK_KHR_pipeline_executable_properties ===
10091	vkGetPipelineExecutablePropertiesKHR = PFN_vkGetPipelineExecutablePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutablePropertiesKHR" ) );
10092	vkGetPipelineExecutableStatisticsKHR = PFN_vkGetPipelineExecutableStatisticsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableStatisticsKHR" ) );
10093	vkGetPipelineExecutableInternalRepresentationsKHR = PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableInternalRepresentationsKHR" ) );
10094
10095	//=== VK_EXT_swapchain_maintenance1 ===
10096	vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesEXT( vkGetDeviceProcAddr( device, "vkReleaseSwapchainImagesEXT" ) );
10097
10098	//=== VK_NV_device_generated_commands ===
10099	vkGetGeneratedCommandsMemoryRequirementsNV = PFN_vkGetGeneratedCommandsMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetGeneratedCommandsMemoryRequirementsNV" ) );
10100	vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsNV" ) );
10101	vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdExecuteGeneratedCommandsNV" ) );
10102	vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV( vkGetDeviceProcAddr( device, "vkCmdBindPipelineShaderGroupNV" ) );
10103	vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutNV" ) );
10104	vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutNV" ) );
10105
10106	//=== VK_EXT_private_data ===
10107	vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlotEXT" ) );
10108	if ( !vkCreatePrivateDataSlot ) vkCreatePrivateDataSlot = vkCreatePrivateDataSlotEXT;
10109	vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlotEXT" ) );
10110	if ( !vkDestroyPrivateDataSlot ) vkDestroyPrivateDataSlot = vkDestroyPrivateDataSlotEXT;
10111	vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkSetPrivateDataEXT" ) );
10112	if ( !vkSetPrivateData ) vkSetPrivateData = vkSetPrivateDataEXT;
10113	vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkGetPrivateDataEXT" ) );
10114	if ( !vkGetPrivateData ) vkGetPrivateData = vkGetPrivateDataEXT;
10115
10116	#if defined( VK_ENABLE_BETA_EXTENSIONS )
10117	//=== VK_KHR_video_encode_queue ===
10118	vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ) );
10119	#endif /*VK_ENABLE_BETA_EXTENSIONS*/
10120
10121	#if defined( VK_USE_PLATFORM_METAL_EXT )
10122	//=== VK_EXT_metal_objects ===
10123	vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetDeviceProcAddr( device, "vkExportMetalObjectsEXT" ) );
10124	#endif /*VK_USE_PLATFORM_METAL_EXT*/
10125
10126	//=== VK_KHR_synchronization2 ===
10127	vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdSetEvent2KHR" ) );
10128	if ( !vkCmdSetEvent2 ) vkCmdSetEvent2 = vkCmdSetEvent2KHR;
10129	vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdResetEvent2KHR" ) );
10130	if ( !vkCmdResetEvent2 ) vkCmdResetEvent2 = vkCmdResetEvent2KHR;
10131	vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2KHR" ) );
10132	if ( !vkCmdWaitEvents2 ) vkCmdWaitEvents2 = vkCmdWaitEvents2KHR;
10133	vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2KHR" ) );
10134	if ( !vkCmdPipelineBarrier2 ) vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR;
10135	vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2KHR" ) );
10136	if ( !vkCmdWriteTimestamp2 ) vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR;
10137	vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetDeviceProcAddr( device, "vkQueueSubmit2KHR" ) );
10138	if ( !vkQueueSubmit2 ) vkQueueSubmit2 = vkQueueSubmit2KHR;
10139	vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarker2AMD" ) );
10140	vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointData2NV" ) );
10141
10142	//=== VK_EXT_descriptor_buffer ===
10143	vkGetDescriptorSetLayoutSizeEXT = PFN_vkGetDescriptorSetLayoutSizeEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSizeEXT" ) );
10144	vkGetDescriptorSetLayoutBindingOffsetEXT = PFN_vkGetDescriptorSetLayoutBindingOffsetEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutBindingOffsetEXT" ) );
10145	vkGetDescriptorEXT = PFN_vkGetDescriptorEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorEXT" ) );
10146	vkCmdBindDescriptorBuffersEXT = PFN_vkCmdBindDescriptorBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBuffersEXT" ) );
10147	vkCmdSetDescriptorBufferOffsetsEXT = PFN_vkCmdSetDescriptorBufferOffsetsEXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsetsEXT" ) );
10148	vkCmdBindDescriptorBufferEmbeddedSamplersEXT = PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT" ) );
10149	vkGetBufferOpaqueCaptureDescriptorDataEXT = PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureDescriptorDataEXT" ) );
10150	vkGetImageOpaqueCaptureDescriptorDataEXT = PFN_vkGetImageOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageOpaqueCaptureDescriptorDataEXT" ) );
10151	vkGetImageViewOpaqueCaptureDescriptorDataEXT = PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageViewOpaqueCaptureDescriptorDataEXT" ) );
10152	vkGetSamplerOpaqueCaptureDescriptorDataEXT = PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetSamplerOpaqueCaptureDescriptorDataEXT" ) );
10153	vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) );
10154
10155	//=== VK_NV_fragment_shading_rate_enums ===
10156	vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateEnumNV" ) );
10157
10158	//=== VK_EXT_mesh_shader ===
10159	vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksEXT" ) );
10160	vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectEXT" ) );
10161	vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountEXT" ) );
10162
10163	//=== VK_KHR_copy_commands2 ===
10164	vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2KHR" ) );
10165	if ( !vkCmdCopyBuffer2 ) vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR;
10166	vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImage2KHR" ) );
10167	if ( !vkCmdCopyImage2 ) vkCmdCopyImage2 = vkCmdCopyImage2KHR;
10168	vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2KHR" ) );
10169	if ( !vkCmdCopyBufferToImage2 ) vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR;
10170	vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2KHR" ) );
10171	if ( !vkCmdCopyImageToBuffer2 ) vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR;
10172	vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetDeviceProcAddr( device, "vkCmdBlitImage2KHR" ) );
10173	if ( !vkCmdBlitImage2 ) vkCmdBlitImage2 = vkCmdBlitImage2KHR;
10174	vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetDeviceProcAddr( device, "vkCmdResolveImage2KHR" ) );
10175	if ( !vkCmdResolveImage2 ) vkCmdResolveImage2 = vkCmdResolveImage2KHR;
10176
10177	//=== VK_EXT_image_compression_control ===
10178	vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2EXT" ) );
10179
10180	//=== VK_EXT_device_fault ===
10181	vkGetDeviceFaultInfoEXT = PFN_vkGetDeviceFaultInfoEXT( vkGetDeviceProcAddr( device, "vkGetDeviceFaultInfoEXT" ) );
10182
10183	//=== VK_KHR_ray_tracing_pipeline ===
10184	vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysKHR" ) );
10185	vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesKHR" ) );
10186	vkGetRayTracingShaderGroupHandlesKHR = PFN_vkGetRayTracingShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesKHR" ) );
10187	vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) );
10188	vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirectKHR" ) );
10189	vkGetRayTracingShaderGroupStackSizeKHR = PFN_vkGetRayTracingShaderGroupStackSizeKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupStackSizeKHR" ) );
10190	vkCmdSetRayTracingPipelineStackSizeKHR = PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetDeviceProcAddr( device, "vkCmdSetRayTracingPipelineStackSizeKHR" ) );
10191
10192	//=== VK_EXT_vertex_input_dynamic_state ===
10193	vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetDeviceProcAddr( device, "vkCmdSetVertexInputEXT" ) );
10194
10195	#if defined( VK_USE_PLATFORM_FUCHSIA )
10196	//=== VK_FUCHSIA_external_memory ===
10197	vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandleFUCHSIA" ) );
10198	vkGetMemoryZirconHandlePropertiesFUCHSIA = PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) );
10199	#endif /*VK_USE_PLATFORM_FUCHSIA*/
10200
10201	#if defined( VK_USE_PLATFORM_FUCHSIA )
10202	//=== VK_FUCHSIA_external_semaphore ===
10203	vkImportSemaphoreZirconHandleFUCHSIA = PFN_vkImportSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkImportSemaphoreZirconHandleFUCHSIA" ) );
10204	vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetSemaphoreZirconHandleFUCHSIA" ) );
10205	#endif /*VK_USE_PLATFORM_FUCHSIA*/
10206
10207	#if defined( VK_USE_PLATFORM_FUCHSIA )
10208	//=== VK_FUCHSIA_buffer_collection ===
10209	vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkCreateBufferCollectionFUCHSIA" ) );
10210	vkSetBufferCollectionImageConstraintsFUCHSIA = PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) );
10211	vkSetBufferCollectionBufferConstraintsFUCHSIA = PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) );
10212	vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkDestroyBufferCollectionFUCHSIA" ) );
10213	vkGetBufferCollectionPropertiesFUCHSIA = PFN_vkGetBufferCollectionPropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetBufferCollectionPropertiesFUCHSIA" ) );
10214	#endif /*VK_USE_PLATFORM_FUCHSIA*/
10215
10216	//=== VK_HUAWEI_subpass_shading ===
10217	vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( vkGetDeviceProcAddr( device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) );
10218	vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI( vkGetDeviceProcAddr( device, "vkCmdSubpassShadingHUAWEI" ) );
10219
10220	//=== VK_HUAWEI_invocation_mask ===
10221	vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI( vkGetDeviceProcAddr( device, "vkCmdBindInvocationMaskHUAWEI" ) );
10222
10223	//=== VK_NV_external_memory_rdma ===
10224	vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV( vkGetDeviceProcAddr( device, "vkGetMemoryRemoteAddressNV" ) );
10225
10226	//=== VK_EXT_pipeline_properties ===
10227	vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetPipelinePropertiesEXT" ) );
10228
10229	//=== VK_EXT_extended_dynamic_state2 ===
10230	vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetDeviceProcAddr( device, "vkCmdSetPatchControlPointsEXT" ) );
10231	vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnableEXT" ) );
10232	if ( !vkCmdSetRasterizerDiscardEnable ) vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT;
10233	vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnableEXT" ) );
10234	if ( !vkCmdSetDepthBiasEnable ) vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT;
10235	vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEXT" ) );
10236	vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnableEXT" ) );
10237	if ( !vkCmdSetPrimitiveRestartEnable ) vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT;
10238
10239	//=== VK_EXT_color_write_enable ===
10240	vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteEnableEXT" ) );
10241
10242	//=== VK_KHR_ray_tracing_maintenance1 ===
10243	vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirect2KHR" ) );
10244
10245	//=== VK_EXT_multi_draw ===
10246	vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiEXT" ) );
10247	vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiIndexedEXT" ) );
10248
10249	//=== VK_EXT_opacity_micromap ===
10250	vkCreateMicromapEXT = PFN_vkCreateMicromapEXT( vkGetDeviceProcAddr( device, "vkCreateMicromapEXT" ) );
10251	vkDestroyMicromapEXT = PFN_vkDestroyMicromapEXT( vkGetDeviceProcAddr( device, "vkDestroyMicromapEXT" ) );
10252	vkCmdBuildMicromapsEXT = PFN_vkCmdBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkCmdBuildMicromapsEXT" ) );
10253	vkBuildMicromapsEXT = PFN_vkBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkBuildMicromapsEXT" ) );
10254	vkCopyMicromapEXT = PFN_vkCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapEXT" ) );
10255	vkCopyMicromapToMemoryEXT = PFN_vkCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapToMemoryEXT" ) );
10256	vkCopyMemoryToMicromapEXT = PFN_vkCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToMicromapEXT" ) );
10257	vkWriteMicromapsPropertiesEXT = PFN_vkWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkWriteMicromapsPropertiesEXT" ) );
10258	vkCmdCopyMicromapEXT = PFN_vkCmdCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapEXT" ) );
10259	vkCmdCopyMicromapToMemoryEXT = PFN_vkCmdCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapToMemoryEXT" ) );
10260	vkCmdCopyMemoryToMicromapEXT = PFN_vkCmdCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToMicromapEXT" ) );
10261	vkCmdWriteMicromapsPropertiesEXT = PFN_vkCmdWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkCmdWriteMicromapsPropertiesEXT" ) );
10262	vkGetDeviceMicromapCompatibilityEXT = PFN_vkGetDeviceMicromapCompatibilityEXT( vkGetDeviceProcAddr( device, "vkGetDeviceMicromapCompatibilityEXT" ) );
10263	vkGetMicromapBuildSizesEXT = PFN_vkGetMicromapBuildSizesEXT( vkGetDeviceProcAddr( device, "vkGetMicromapBuildSizesEXT" ) );
10264
10265	//=== VK_EXT_pageable_device_local_memory ===
10266	vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT( vkGetDeviceProcAddr( device, "vkSetDeviceMemoryPriorityEXT" ) );
10267
10268	//=== VK_KHR_maintenance4 ===
10269	vkGetDeviceBufferMemoryRequirementsKHR = PFN_vkGetDeviceBufferMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirementsKHR" ) );
10270	if ( !vkGetDeviceBufferMemoryRequirements ) vkGetDeviceBufferMemoryRequirements = vkGetDeviceBufferMemoryRequirementsKHR;
10271	vkGetDeviceImageMemoryRequirementsKHR = PFN_vkGetDeviceImageMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirementsKHR" ) );
10272	if ( !vkGetDeviceImageMemoryRequirements ) vkGetDeviceImageMemoryRequirements = vkGetDeviceImageMemoryRequirementsKHR;
10273	vkGetDeviceImageSparseMemoryRequirementsKHR = PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) );
10274	if ( !vkGetDeviceImageSparseMemoryRequirements ) vkGetDeviceImageSparseMemoryRequirements = vkGetDeviceImageSparseMemoryRequirementsKHR;
10275
10276	//=== VK_VALVE_descriptor_set_host_mapping ===
10277	vkGetDescriptorSetLayoutHostMappingInfoVALVE = PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE" ) );
10278	vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetHostMappingVALVE" ) );
10279
10280	//=== VK_NV_copy_memory_indirect ===
10281	vkCmdCopyMemoryIndirectNV = PFN_vkCmdCopyMemoryIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryIndirectNV" ) );
10282	vkCmdCopyMemoryToImageIndirectNV = PFN_vkCmdCopyMemoryToImageIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageIndirectNV" ) );
10283
10284	//=== VK_NV_memory_decompression ===
10285	vkCmdDecompressMemoryNV = PFN_vkCmdDecompressMemoryNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryNV" ) );
10286	vkCmdDecompressMemoryIndirectCountNV = PFN_vkCmdDecompressMemoryIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryIndirectCountNV" ) );
10287
10288	//=== VK_EXT_extended_dynamic_state3 ===
10289	vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetDeviceProcAddr( device, "vkCmdSetTessellationDomainOriginEXT" ) );
10290	vkCmdSetDepthClampEnableEXT = PFN_vkCmdSetDepthClampEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClampEnableEXT" ) );
10291	vkCmdSetPolygonModeEXT = PFN_vkCmdSetPolygonModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetPolygonModeEXT" ) );
10292	vkCmdSetRasterizationSamplesEXT = PFN_vkCmdSetRasterizationSamplesEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationSamplesEXT" ) );
10293	vkCmdSetSampleMaskEXT = PFN_vkCmdSetSampleMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleMaskEXT" ) );
10294	vkCmdSetAlphaToCoverageEnableEXT = PFN_vkCmdSetAlphaToCoverageEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToCoverageEnableEXT" ) );
10295	vkCmdSetAlphaToOneEnableEXT = PFN_vkCmdSetAlphaToOneEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToOneEnableEXT" ) );
10296	vkCmdSetLogicOpEnableEXT = PFN_vkCmdSetLogicOpEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEnableEXT" ) );
10297	vkCmdSetColorBlendEnableEXT = PFN_vkCmdSetColorBlendEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEnableEXT" ) );
10298	vkCmdSetColorBlendEquationEXT = PFN_vkCmdSetColorBlendEquationEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEquationEXT" ) );
10299	vkCmdSetColorWriteMaskEXT = PFN_vkCmdSetColorWriteMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteMaskEXT" ) );
10300	vkCmdSetRasterizationStreamEXT = PFN_vkCmdSetRasterizationStreamEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationStreamEXT" ) );
10301	vkCmdSetConservativeRasterizationModeEXT = PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetConservativeRasterizationModeEXT" ) );
10302	vkCmdSetExtraPrimitiveOverestimationSizeEXT = PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT( vkGetDeviceProcAddr( device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT" ) );
10303	vkCmdSetDepthClipEnableEXT = PFN_vkCmdSetDepthClipEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipEnableEXT" ) );
10304	vkCmdSetSampleLocationsEnableEXT = PFN_vkCmdSetSampleLocationsEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEnableEXT" ) );
10305	vkCmdSetColorBlendAdvancedEXT = PFN_vkCmdSetColorBlendAdvancedEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendAdvancedEXT" ) );
10306	vkCmdSetProvokingVertexModeEXT = PFN_vkCmdSetProvokingVertexModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetProvokingVertexModeEXT" ) );
10307	vkCmdSetLineRasterizationModeEXT = PFN_vkCmdSetLineRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineRasterizationModeEXT" ) );
10308	vkCmdSetLineStippleEnableEXT = PFN_vkCmdSetLineStippleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEnableEXT" ) );
10309	vkCmdSetDepthClipNegativeOneToOneEXT = PFN_vkCmdSetDepthClipNegativeOneToOneEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipNegativeOneToOneEXT" ) );
10310	vkCmdSetViewportWScalingEnableNV = PFN_vkCmdSetViewportWScalingEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingEnableNV" ) );
10311	vkCmdSetViewportSwizzleNV = PFN_vkCmdSetViewportSwizzleNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportSwizzleNV" ) );
10312	vkCmdSetCoverageToColorEnableNV = PFN_vkCmdSetCoverageToColorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorEnableNV" ) );
10313	vkCmdSetCoverageToColorLocationNV = PFN_vkCmdSetCoverageToColorLocationNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorLocationNV" ) );
10314	vkCmdSetCoverageModulationModeNV = PFN_vkCmdSetCoverageModulationModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationModeNV" ) );
10315	vkCmdSetCoverageModulationTableEnableNV = PFN_vkCmdSetCoverageModulationTableEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableEnableNV" ) );
10316	vkCmdSetCoverageModulationTableNV = PFN_vkCmdSetCoverageModulationTableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableNV" ) );
10317	vkCmdSetShadingRateImageEnableNV = PFN_vkCmdSetShadingRateImageEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetShadingRateImageEnableNV" ) );
10318	vkCmdSetRepresentativeFragmentTestEnableNV = PFN_vkCmdSetRepresentativeFragmentTestEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetRepresentativeFragmentTestEnableNV" ) );
10319	vkCmdSetCoverageReductionModeNV = PFN_vkCmdSetCoverageReductionModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageReductionModeNV" ) );
10320
10321	//=== VK_EXT_shader_module_identifier ===
10322	vkGetShaderModuleIdentifierEXT = PFN_vkGetShaderModuleIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleIdentifierEXT" ) );
10323	vkGetShaderModuleCreateInfoIdentifierEXT = PFN_vkGetShaderModuleCreateInfoIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleCreateInfoIdentifierEXT" ) );
10324
10325	//=== VK_NV_optical_flow ===
10326	vkCreateOpticalFlowSessionNV = PFN_vkCreateOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkCreateOpticalFlowSessionNV" ) );
10327	vkDestroyOpticalFlowSessionNV = PFN_vkDestroyOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkDestroyOpticalFlowSessionNV" ) );
10328	vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetDeviceProcAddr( device, "vkBindOpticalFlowSessionImageNV" ) );
10329	vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetDeviceProcAddr( device, "vkCmdOpticalFlowExecuteNV" ) );
10330
10331	//=== VK_QCOM_tile_properties ===
10332	vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) );
10333	vkGetDynamicRenderingTilePropertiesQCOM = PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetDynamicRenderingTilePropertiesQCOM" ) );
10334
10335	}
10336
10337	template <typename DynamicLoader>
10338	void init(VULKAN_HPP_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::Device const & device, DynamicLoader const & dl) VULKAN_HPP_NOEXCEPT
10339	{
10340	PFN_vkGetInstanceProcAddr getInstanceProcAddr = dl.template getProcAddress<PFN_vkGetInstanceProcAddr>("vkGetInstanceProcAddr");
10341	PFN_vkGetDeviceProcAddr getDeviceProcAddr = dl.template getProcAddress<PFN_vkGetDeviceProcAddr>("vkGetDeviceProcAddr");
10342	init(instance: static_cast<VkInstance>(instance), getInstanceProcAddr, device: static_cast<VkDevice>(device), device ? getDeviceProcAddr : nullptr);
10343	}
10344
10345	template <typename DynamicLoader
10346	#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
10347	= VULKAN_HPP_NAMESPACE::DynamicLoader
10348	#endif
10349	>
10350	void init(VULKAN_HPP_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::Device const & device) VULKAN_HPP_NOEXCEPT
10351	{
10352	static DynamicLoader dl;
10353	init(instance, device, dl);
10354	}
10355	};
10356	} // namespace VULKAN_HPP_NAMESPACE
10357	#endif
10358