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 )
89typedef struct HINSTANCE__ * HINSTANCE;
90# if defined( _WIN64 )
91typedef int64_t( __stdcall * FARPROC )();
92# else
93typedef int( __stdcall * FARPROC )();
94# endif
95extern "C" __declspec( dllimport ) HINSTANCE __stdcall LoadLibraryA( char const * lpLibFileName );
96extern "C" __declspec( dllimport ) int __stdcall FreeLibrary( HINSTANCE hLibModule );
97extern "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
118static_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
238namespace 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
5664namespace std
5665{
5666 template <>
5667 struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type
5668 {};
5669} // namespace std
5670#endif
5671
5672namespace 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
6253namespace 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

Provided by KDAB

Privacy Policy
Learn more about Flutter for embedded and desktop on industrialflutter.com

source code of flutter_engine/third_party/swiftshader/include/vulkan/vulkan.hpp